{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Small Benchmark\n",
    "This notebook runs a small benchmark for  ParquetDB, PyArrow, and SQLite across comparable read/write/query operations. This was first conducted by Christopher Körber and adapated by Logan Lang for this notebook\n",
    "\n",
    "## Benchmark Details\n",
    "- **Data Generation:** Generates 1,000,000 rows × 100 columns of integers (0–1,000,000). Integers are chosen as a basic primitive type—byte size is the main factor, so these results represent a **lower bound** on performance; more complex or larger types will incur higher cost.\n",
    "- **ParquetDB Normalization (defaults):** row-group size 50,000–100,000 rows, max rows per file 10,000,000. Tuning these can shift performance between inserts, reads, and updates.\n",
    "\n",
    "## System Specifications\n",
    "- **Operating System:** Windows 10  \n",
    "- **Processor:** AMD Ryzen 7 3700X 8‑Core @ 3.6 MHz (8 cores, 16 logical processors)  \n",
    "- **Memory:** 128 GB DDR4‑3600 MHz (4×32 GB DIMMs) \n",
    "- **Storage**: SATA HDD 2TB (Model: ST2000DM008-2FR102)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install parquetdb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "import time\n",
    "import shutil\n",
    "\n",
    "import numpy as np\n",
    "import pyarrow as pa\n",
    "import pyarrow.parquet as pq\n",
    "import pyarrow.dataset as ds\n",
    "\n",
    "from parquetdb import config\n",
    "from parquetdb.utils import general_utils\n",
    "\n",
    "bench_dir = os.path.join(config.data_dir, 'benchmarks')\n",
    "sqlite_dir = os.path.join(bench_dir, 'sqlite')\n",
    "pa_dir = os.path.join(bench_dir, 'pyarrow')\n",
    "pq_dir = os.path.join(bench_dir, 'parquetdb')\n",
    "\n",
    "for d in (sqlite_dir, pa_dir, pq_dir):\n",
    "    os.makedirs(d, exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "orders=np.arange(7)\n",
    "data_dict = {}\n",
    "\n",
    "col_prefix = \"col\"\n",
    "for order in orders:\n",
    "    data_dict[order] = general_utils.generate_pylist_data(n_rows=10**order, min_value=0, max_value=1_000_000, prefix=col_prefix) \n",
    "    \n",
    "parquetdb_filters = [pa.compute.field(f\"{col_prefix}1\") > 100, pa.compute.field(f\"{col_prefix}97\") < 1000]\n",
    "pyarrow_filter = (pa.compute.field(f\"{col_prefix}1\") > 100) & (pa.compute.field(f\"{col_prefix}97\") < 1000)\n",
    "sql_query = f\"{col_prefix}1 > 100 and {col_prefix}97 < 1000\"\n",
    "\n",
    "CREATE_TIMES={\n",
    "    \"parquetdb\":{\"mean\":[], \"std\":[]},\n",
    "    \"pyarrow\":{\"mean\":[], \"std\":[]},\n",
    "    \"sqlite\":{\"mean\":[], \"std\":[]}\n",
    "}\n",
    "\n",
    "READ_TIMES={\n",
    "    \"parquetdb\":{\"mean\":[], \"std\":[]},\n",
    "    \"pyarrow\":{\"mean\":[], \"std\":[]},\n",
    "    \"sqlite\":{\"mean\":[], \"std\":[]}\n",
    "}\n",
    "\n",
    "QUERY_TIMES={\n",
    "    \"parquetdb\":{\"mean\":[], \"std\":[]},\n",
    "    \"pyarrow\":{\"mean\":[], \"std\":[]},\n",
    "    \"sqlite\":{\"mean\":[], \"std\":[]}\n",
    "}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Using PyArrow Directly"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "pyarrow_dir = os.path.join(pa_dir, \"pyarrow\")\n",
    "\n",
    "def pyarrow_benchmark_experiment(data):\n",
    "    \n",
    "    if os.path.exists(pyarrow_dir):\n",
    "        shutil.rmtree(pyarrow_dir)\n",
    "    os.makedirs(pyarrow_dir, exist_ok=True)\n",
    "    \n",
    "    \n",
    "    create_time = time.time()\n",
    "    start = 0 \n",
    "    table = pa.Table.from_pylist(data).add_column(0, 'id', [range(start, start + len(data))])\n",
    "    temp_file_path=os.path.join(pyarrow_dir, \"0.parquet\")\n",
    "    pq.write_table(table, temp_file_path)\n",
    "    create_time=time.time() - create_time\n",
    "    del table\n",
    "    \n",
    "    read_time = time.time()\n",
    "    dataset = ds.dataset(pyarrow_dir, format=\"parquet\")\n",
    "    table=dataset.to_table(filter=None)\n",
    "    read_time = time.time() - read_time\n",
    "    del table\n",
    "    del dataset\n",
    "\n",
    "    query_time = time.time()\n",
    "    dataset = ds.dataset(pyarrow_dir, format=\"parquet\")\n",
    "    table=dataset.to_table(filter=pyarrow_filter)\n",
    "    query_time = time.time() - query_time\n",
    "    \n",
    "    return create_time, read_time, query_time\n",
    "    \n",
    "    \n",
    "experiment_dict = { key: {} for key in range(5)}\n",
    "for run_name, benchmark_dict in experiment_dict.items():\n",
    "    tmp_dict={}\n",
    "          \n",
    "    create_times = []\n",
    "    read_times = []\n",
    "    query_times=[]\n",
    "    for order, data in data_dict.items():\n",
    "        create_time, read_time, query_time = pyarrow_benchmark_experiment(data)\n",
    "        create_times.append(create_time)\n",
    "        read_times.append(read_time)\n",
    "        query_times.append(query_time)\n",
    "        \n",
    "    tmp_dict = {\n",
    "        \"create_times\": create_times,\n",
    "        \"read_times\": read_times,\n",
    "        \"query_times\": query_times\n",
    "    }\n",
    "    benchmark_dict[run_name] = tmp_dict\n",
    "\n",
    "mean_create_times=[]\n",
    "mean_read_times=[]\n",
    "mean_query_times=[]\n",
    "\n",
    "std_create_times=[]\n",
    "std_read_times=[]\n",
    "std_query_times=[]\n",
    "for order, data in data_dict.items():\n",
    "    tmp_create_times=[]\n",
    "    tmp_read_times=[]\n",
    "    tmp_query_times=[]\n",
    "    for run_name, benchmark_dict in experiment_dict.items():\n",
    "        tmp_create_times.append(benchmark_dict[run_name]['create_times'][order])\n",
    "        tmp_read_times.append(benchmark_dict[run_name]['read_times'][order])\n",
    "        tmp_query_times.append(benchmark_dict[run_name]['query_times'][order])\n",
    "    mean_create_times.append(float(np.mean(tmp_create_times)))\n",
    "    mean_read_times.append(float(np.mean(tmp_read_times)))\n",
    "    mean_query_times.append(float(np.mean(tmp_query_times)))\n",
    "    std_create_times.append(float(np.std(tmp_create_times)))\n",
    "    std_read_times.append(float(np.std(tmp_read_times)))\n",
    "    std_query_times.append(float(np.std(tmp_query_times)))\n",
    "\n",
    "\n",
    "CREATE_TIMES['pyarrow'][\"mean\"] = mean_create_times\n",
    "CREATE_TIMES['pyarrow'][\"std\"] = std_create_times\n",
    "\n",
    "READ_TIMES['pyarrow'][\"mean\"] = mean_read_times\n",
    "READ_TIMES['pyarrow'][\"std\"] = std_read_times\n",
    "\n",
    "QUERY_TIMES['pyarrow'][\"mean\"] = mean_query_times\n",
    "QUERY_TIMES['pyarrow'][\"std\"] = std_query_times\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create Times:\n",
      "[0.03320021629333496, 0.014103555679321289, 0.009400510787963867, 0.03350682258605957, 0.471631383895874, 7.403422498703003, 70.13993415832519]\n",
      "Read Times:\n",
      "[0.014600133895874024, 0.015394306182861328, 0.012600994110107422, 0.012792396545410156, 0.01582474708557129, 0.05335421562194824, 0.35906219482421875]\n",
      "Query Times:\n",
      "[0.005000877380371094, 0.004373693466186523, 0.004302406311035156, 0.006783628463745117, 0.009602928161621093, 0.04960236549377441, 0.30310521125793455]\n"
     ]
    }
   ],
   "source": [
    "print(\"Create Times:\")\n",
    "print(CREATE_TIMES['pyarrow'][\"mean\"])\n",
    "print(\"Read Times:\")\n",
    "print(READ_TIMES['pyarrow'][\"mean\"])\n",
    "print(\"Query Times:\")\n",
    "print(QUERY_TIMES['pyarrow'][\"mean\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## SQLite"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sqlite3\n",
    "import traceback\n",
    "import sys\n",
    "sqlite_db = os.path.join(sqlite_dir, \"benchmark.sqlite\")\n",
    "\n",
    "def sqlite_benchmark_experiment(data):\n",
    "    if os.path.exists(sqlite_db): os.remove(sqlite_db)\n",
    "    \n",
    "    sql_data_keys = data[0].keys()\n",
    "    sql_data_values=[]\n",
    "    for record in data:\n",
    "        # for key,value in record.items():\n",
    "        sql_data_values.append(tuple(record.values()))\n",
    "    n_cols = len(data[0])\n",
    "\n",
    "    try:\n",
    "        create_time = time.time()\n",
    "        conn = sqlite3.connect(sqlite_db)\n",
    "        cursor = conn.cursor()\n",
    "        cursor.execute(\"PRAGMA synchronous = OFF\")\n",
    "        cursor.execute(\"PRAGMA journal_mode = MEMORY\")\n",
    "        cols = ', '.join(f'{data_key} INTEGER' for data_key in sql_data_keys)\n",
    "        \n",
    "        conn.execute(f'CREATE TABLE benchmark ({cols})')\n",
    "        placeholders = ', '.join('?' for _ in range(n_cols))\n",
    "        sql= f'INSERT INTO benchmark VALUES ({placeholders})'\n",
    "        \n",
    "        cursor.executemany(sql, sql_data_values)  \n",
    "        conn.commit()\n",
    "        create_time=time.time() - create_time\n",
    "    except Exception as e:\n",
    "        # Get the traceback information as a formatted string\n",
    "        tb_str = traceback.format_exc()\n",
    "        print(tb_str)\n",
    "        # Or, get the traceback object and work with it directly\n",
    "        tb = sys.exc_info()[2]\n",
    "        traceback.print_tb(tb)\n",
    "    conn.close()\n",
    "    \n",
    "    \n",
    "    try:\n",
    "        read_time = time.time()\n",
    "        conn = sqlite3.connect(sqlite_db)\n",
    "        cursor = conn.cursor()\n",
    "        cursor.execute(\"SELECT * FROM benchmark\")\n",
    "        results = cursor.fetchall()\n",
    "        read_time = time.time() - read_time\n",
    "\n",
    "    except Exception as e:\n",
    "        # Get the traceback information as a formatted string\n",
    "        tb_str = traceback.format_exc()\n",
    "        print(tb_str)\n",
    "        # Or, get the traceback object and work with it directly\n",
    "        tb = sys.exc_info()[2]\n",
    "        traceback.print_tb(tb)\n",
    "    conn.close()\n",
    "    \n",
    "    try:\n",
    "        query_time = time.time()\n",
    "        conn = sqlite3.connect(sqlite_db)\n",
    "        cursor = conn.cursor()\n",
    "        cursor.execute(f\"SELECT * FROM benchmark WHERE {sql_query}\")\n",
    "        results = cursor.fetchall()\n",
    "        query_time = time.time() - query_time\n",
    "    except Exception as e:\n",
    "        # Get the traceback information as a formatted string\n",
    "        tb_str = traceback.format_exc()\n",
    "        print(tb_str)\n",
    "        # Or, get the traceback object and work with it directly\n",
    "        tb = sys.exc_info()[2]\n",
    "        traceback.print_tb(tb)\n",
    "    conn.close()\n",
    "                \n",
    "    \n",
    "    return create_time, read_time, query_time\n",
    "\n",
    "\n",
    "experiment_dict = { key: {} for key in range(5)}\n",
    "for run_name, benchmark_dict in experiment_dict.items():\n",
    "    tmp_dict={}\n",
    "          \n",
    "    create_times = []\n",
    "    read_times = []\n",
    "    query_times=[]\n",
    "    for order, data in data_dict.items():\n",
    "        create_time, read_time, query_time = sqlite_benchmark_experiment(data)\n",
    "        create_times.append(create_time)\n",
    "        read_times.append(read_time)\n",
    "        query_times.append(query_time)\n",
    "        \n",
    "    tmp_dict = {\n",
    "        \"create_times\": create_times,\n",
    "        \"read_times\": read_times,\n",
    "        \"query_times\": query_times\n",
    "    }\n",
    "    benchmark_dict[run_name] = tmp_dict\n",
    "\n",
    "mean_create_times=[]\n",
    "mean_read_times=[]\n",
    "mean_query_times=[]\n",
    "\n",
    "std_create_times=[]\n",
    "std_read_times=[]\n",
    "std_query_times=[]\n",
    "for order, data in data_dict.items():\n",
    "    tmp_create_times=[]\n",
    "    tmp_read_times=[]\n",
    "    tmp_query_times=[]\n",
    "    for run_name, benchmark_dict in experiment_dict.items():\n",
    "        tmp_create_times.append(benchmark_dict[run_name]['create_times'][order])\n",
    "        tmp_read_times.append(benchmark_dict[run_name]['read_times'][order])\n",
    "        tmp_query_times.append(benchmark_dict[run_name]['query_times'][order])\n",
    "\n",
    "    mean_create_times.append(float(np.mean(tmp_create_times)))\n",
    "    mean_read_times.append(float(np.mean(tmp_read_times)))\n",
    "    mean_query_times.append(float(np.mean(tmp_query_times)))\n",
    "    std_create_times.append(float(np.std(tmp_create_times)))\n",
    "    std_read_times.append(float(np.std(tmp_read_times)))\n",
    "    std_query_times.append(float(np.std(tmp_query_times)))\n",
    "\n",
    "\n",
    "CREATE_TIMES['sqlite'][\"mean\"] = mean_create_times\n",
    "CREATE_TIMES['sqlite'][\"std\"] = std_create_times\n",
    "\n",
    "READ_TIMES['sqlite'][\"mean\"] = mean_read_times\n",
    "READ_TIMES['sqlite'][\"std\"] = std_read_times\n",
    "\n",
    "QUERY_TIMES['sqlite'][\"mean\"] = mean_query_times\n",
    "QUERY_TIMES['sqlite'][\"std\"] = std_query_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create Times:\n",
      "[0.0010138988494873048, 0.0008130550384521484, 0.0011197566986083985, 0.008905124664306641, 0.07463836669921875, 0.736366605758667, 7.4553422927856445]\n",
      "Read Times:\n",
      "[0.0013258934020996093, 0.0015575885772705078, 0.0031287670135498047, 0.01792774200439453, 0.16240925788879396, 1.6550938606262207, 16.552225065231323]\n",
      "Query Times:\n",
      "[0.00040950775146484373, 0.00030159950256347656, 0.0005053997039794922, 0.001902294158935547, 0.016704320907592773, 0.18021435737609864, 1.7924356937408448]\n"
     ]
    }
   ],
   "source": [
    "print(\"Create Times:\")\n",
    "print(CREATE_TIMES['sqlite'][\"mean\"])\n",
    "print(\"Read Times:\")\n",
    "print(READ_TIMES['sqlite'][\"mean\"])\n",
    "print(\"Query Times:\")\n",
    "print(QUERY_TIMES['sqlite'][\"mean\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## ParquetDB"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "from parquetdb import ParquetDB\n",
    "\n",
    "parquetdb_dir = os.path.join(pq_dir, \"parquetdb\", \"BenchmarkDB\")\n",
    "\n",
    "def parquetdb_benchmark_experiment(data):\n",
    "    \n",
    "    time.sleep(1)\n",
    "    if os.path.exists(parquetdb_dir):\n",
    "        shutil.rmtree(parquetdb_dir)\n",
    "    os.makedirs(parquetdb_dir, exist_ok=True)\n",
    "    \n",
    "    db = ParquetDB(db_path=parquetdb_dir)\n",
    "    \n",
    "    \n",
    "    create_time = time.time()\n",
    "    db.create(data)\n",
    "    create_time=time.time() - create_time\n",
    "\n",
    "    \n",
    "    read_time = time.time()\n",
    "    table=db.read(filters=None)\n",
    "    read_time = time.time() - read_time\n",
    "    del table\n",
    "\n",
    "\n",
    "    query_time = time.time()\n",
    "    table=db.read(filters=parquetdb_filters)\n",
    "    query_time = time.time() - query_time\n",
    "    \n",
    "    return create_time, read_time, query_time\n",
    "    \n",
    "    \n",
    "    \n",
    "\n",
    "\n",
    "experiment_dict = { key: {} for key in range(5)}\n",
    "for run_name, benchmark_dict in experiment_dict.items():\n",
    "    tmp_dict={}\n",
    "          \n",
    "    create_times = []\n",
    "    read_times = []\n",
    "    query_times=[]\n",
    "    for order, data in data_dict.items():\n",
    "        create_time, read_time, query_time = parquetdb_benchmark_experiment(data)\n",
    "        create_times.append(create_time)\n",
    "        read_times.append(read_time)\n",
    "        query_times.append(query_time)\n",
    "        \n",
    "    tmp_dict = {\n",
    "        \"create_times\": create_times,\n",
    "        \"read_times\": read_times,\n",
    "        \"query_times\": query_times\n",
    "    }\n",
    "    benchmark_dict[run_name] = tmp_dict\n",
    "\n",
    "mean_create_times=[]\n",
    "mean_read_times=[]\n",
    "mean_query_times=[]\n",
    "\n",
    "std_create_times=[]\n",
    "std_read_times=[]\n",
    "std_query_times=[]\n",
    "for order, data in data_dict.items():\n",
    "    tmp_create_times=[]\n",
    "    tmp_read_times=[]\n",
    "    tmp_query_times=[]\n",
    "    for run_name, benchmark_dict in experiment_dict.items():\n",
    "        tmp_create_times.append(benchmark_dict[run_name]['create_times'][order])\n",
    "        tmp_read_times.append(benchmark_dict[run_name]['read_times'][order])\n",
    "        tmp_query_times.append(benchmark_dict[run_name]['query_times'][order])\n",
    "\n",
    "    mean_create_times.append(float(np.mean(tmp_create_times)))\n",
    "    mean_read_times.append(float(np.mean(tmp_read_times)))\n",
    "    mean_query_times.append(float(np.mean(tmp_query_times)))\n",
    "    std_create_times.append(float(np.std(tmp_create_times)))\n",
    "    std_read_times.append(float(np.std(tmp_read_times)))\n",
    "    std_query_times.append(float(np.std(tmp_query_times)))\n",
    "\n",
    "\n",
    "CREATE_TIMES['parquetdb'][\"mean\"] = mean_create_times\n",
    "CREATE_TIMES['parquetdb'][\"std\"] = std_create_times\n",
    "\n",
    "READ_TIMES['parquetdb'][\"mean\"] = mean_read_times\n",
    "READ_TIMES['parquetdb'][\"std\"] = std_read_times\n",
    "\n",
    "QUERY_TIMES['parquetdb'][\"mean\"] = mean_query_times\n",
    "QUERY_TIMES['parquetdb'][\"std\"] = std_query_times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Create Times:\n",
      "[0.07000021934509278, 0.1691793441772461, 0.06844029426574708, 0.09826879501342774, 0.4450040340423584, 3.8328524112701414, 32.39931697845459]\n",
      "Read Times:\n",
      "[0.019400930404663085, 0.015804147720336913, 0.016584157943725586, 0.01441502571105957, 0.018503570556640626, 0.10959677696228028, 0.3610626220703125]\n",
      "Query Times:\n",
      "[0.007051420211791992, 0.0063992500305175785, 0.006599617004394531, 0.008312273025512695, 0.012049388885498048, 0.04615607261657715, 0.7494649410247802]\n"
     ]
    }
   ],
   "source": [
    "print(\"Create Times:\")\n",
    "print(CREATE_TIMES['parquetdb'][\"mean\"])\n",
    "print(\"Read Times:\")\n",
    "print(READ_TIMES['parquetdb'][\"mean\"])\n",
    "print(\"Query Times:\")\n",
    "print(QUERY_TIMES['parquetdb'][\"mean\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Plotting results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.ticker as ticker\n",
    "from mpl_toolkits.axes_grid1.inset_locator import inset_axes\n",
    "\n",
    "def plotting_experiments(benchmark_times: dict):\n",
    "    \n",
    "    plt.rcParams.update({\n",
    "        'axes.labelsize': 18, 'axes.titlesize': 18,\n",
    "        'xtick.labelsize': 14, 'ytick.labelsize': 14\n",
    "    })\n",
    "\n",
    "    fig, axes = plt.subplots(figsize=(10, 6))\n",
    "    \n",
    "\n",
    "    # colors, styles\n",
    "    colors = [\"#e52207\", \"#e5a000\",\"#59b9de\"]\n",
    "    linestyle=\"solid\"\n",
    "    markerstyle=\"o\"\n",
    "    marker_fill=\"none\"\n",
    "\n",
    "\n",
    "    n_rows = [10**order for order in orders]\n",
    "    for i, (label, time_dict)  in enumerate(benchmark_times.items()):\n",
    "        mean_times=time_dict['mean']\n",
    "        std_times=time_dict['std']\n",
    "        axes.plot(\n",
    "            n_rows,\n",
    "            mean_times,\n",
    "            label=label,\n",
    "            color=colors[i],\n",
    "            linestyle=linestyle,\n",
    "            marker=markerstyle,\n",
    "            fillstyle=marker_fill,\n",
    "        )\n",
    "        # Add error bars for standard deviation\n",
    "        axes.errorbar(\n",
    "            n_rows,\n",
    "            mean_times,\n",
    "            yerr=std_times,\n",
    "            fmt='none',  # No line connecting error bars\n",
    "            ecolor=colors[i],\n",
    "            elinewidth=1.5,\n",
    "            capsize=3\n",
    "        )\n",
    "        \n",
    "        \n",
    "    scale = 36\n",
    "    ax_inset = inset_axes(\n",
    "        axes,\n",
    "        width=f\"{scale}%\",\n",
    "        height=f\"{scale}%\",\n",
    "        loc=\"upper left\",\n",
    "        bbox_to_anchor=(0.05, -0.03, 1, 1),\n",
    "        bbox_transform=axes.transAxes,\n",
    "        borderpad=2,\n",
    "    )\n",
    "    \n",
    "    for i, (label, time_dict)  in enumerate(benchmark_times.items()):\n",
    "        mean_times=time_dict['mean']\n",
    "        std_times=time_dict['std']\n",
    "        ax_inset.plot(\n",
    "            n_rows,\n",
    "            mean_times,\n",
    "            label=label,\n",
    "            color=colors[i],\n",
    "            markersize=8,\n",
    "            linestyle=linestyle,\n",
    "            marker=markerstyle,\n",
    "            fillstyle=marker_fill,\n",
    "        )\n",
    "        \n",
    "        axes.errorbar(\n",
    "            n_rows,\n",
    "            mean_times,\n",
    "            yerr=std_times,\n",
    "            fmt='none',  # No line connecting error bars\n",
    "            ecolor=colors[i],\n",
    "            elinewidth=1.5,\n",
    "            capsize=3\n",
    "        )\n",
    "    \n",
    "    axes.set_xlabel(\"Number of Rows\")\n",
    "    \n",
    "    axes.spines[\"left\"].set_linestyle(linestyle)\n",
    "    axes.spines[\"left\"].set_linewidth(2.5)\n",
    "    axes.spines[\"right\"].set_visible(False)\n",
    "    axes.tick_params(axis=\"both\", which=\"major\", length=10, width=2, direction=\"out\")\n",
    "    axes.grid(True)\n",
    "    \n",
    "    \n",
    "    ax_inset.grid(True)\n",
    "    ax_inset.set_xscale(\"log\")\n",
    "    ax_inset.set_yscale(\"log\")\n",
    "    ax_inset.set_xlabel(\"Number of Rows (log)\", fontsize=8)\n",
    "    \n",
    "\n",
    "\n",
    "    maj = ticker.LogLocator(numticks=9)\n",
    "    minr = ticker.LogLocator(subs=\"all\", numticks=9)\n",
    "    ax_inset.xaxis.set_major_locator(maj)\n",
    "    ax_inset.xaxis.set_minor_locator(minr)\n",
    "    ax_inset.spines[\"left\"].set_linestyle(linestyle)\n",
    "    ax_inset.spines[\"left\"].set_linewidth(2.5)\n",
    "\n",
    "    ax_inset.spines[\"right\"].set_visible(False)\n",
    "\n",
    "    ax_inset.tick_params(axis=\"both\", which=\"major\", length=6, width=1.5, direction=\"out\")\n",
    "    ax_inset.tick_params(axis=\"x\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "    ax_inset.tick_params(axis=\"y\", which=\"minor\", length=3, width=1, direction=\"out\")\n",
    "    \n",
    "    lines1, labels1 = axes.get_legend_handles_labels()\n",
    "    axes.legend(lines1, labels1, loc=\"upper center\", bbox_to_anchor=(0.15, 0, 1, 1))\n",
    "    return axes, ax_inset\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Create Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_50988\\488313717.py:5: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "axes,ax_inset=plotting_experiments(benchmark_times=CREATE_TIMES)\n",
    "axes.set_title(\"Benchmark for Create Times\")\n",
    "axes.set_ylabel(\"Create Times (s)\")\n",
    "ax_inset.set_ylabel(\"Create Time (log)\", fontsize=8, labelpad=-2)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Read Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "tags": [
     "nbsphinx-thumbnail"
    ]
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_50988\\3302302533.py:5: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA90AAAJOCAYAAACqS2TfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3gU5drA4d9sy6ZtNiGVkoQSem+ClIAgKIKgHwLiEVSs2LEgHvvxcKyIosejokZRAbuioCISJKD0EnoPECA92fRt8/2xZCEkgQAJm02e+7pyJTvzzswzm9nyzNsUVVVVhBBCCCGEEEIIUeM0ng5ACCGEEEIIIYSoryTpFkIIIYQQQgghaokk3UIIIYQQQgghRC2RpFsIIYQQQgghhKglknQLIYQQQgghhBC1RJJuIYQQQgghhBCilkjSLYQQQgghhBBC1BJJuoUQQgghhBBCiFoiSbcQQgghhBBCCFFLJOkWQghRpz333HMoisKgQYM8HYpH3XLLLSiKwi233FIr+z98+DC33nor0dHRGAwGFEXBbDbXyrFE/RYbG4uiKCQkJHg6FCGEqBMk6RZCCC9RlnxW9uPn50dcXByTJ09m9erVng5VeJm8vDz69etHQkICR44cwc/Pj4iICCIiIjwd2lktWbKEO++8kw4dOhASEoJer6dRo0b07t2bhx56iDVr1ng6xAuSkJDAc889R2Ji4iU/dlnCfCE/zz333CWPVwghvIHO0wEIIYQ4f6cnQ06nk+zsbPbt28e+ffv49NNPefbZZ+ULsKi2+fPnc/ToUYKDg1m9ejVt27b1dEhntWfPHm666SbWr1/vXqbVagkKCiIvL49169axbt063nzzTQYPHsyXX35JaGioByM+PwkJCaxYsQLgkrfwCAsLo6SkpMLy4uJiLBYLAKGhoWi12gplAgICAGjZsiVGo5GgoKDaDVYIIbyEJN1CCOGFTpw4Ue6xw+Hg77//5sEHH2TDhg08//zzDBs2jMsvv9xDEQpvkpycDMAVV1xR5xPudevWMWzYMHJzc/H39+eBBx5gwoQJdOrUCUVRcDqd7Nq1i++//5633nqL5cuXc/ToUa9Kuj1p3bp1lS5PSEjg1ltvdZeJjY2tch/Lli2rjdCEEMJrSdIthBD1gFarpV+/fnz//fc0a9YMgB9++EGSblEtRUVFwKmayroqKyuL66+/ntzcXBo3bsxvv/1Ghw4dypXRaDS0b9+e9u3b89BDD/Hwww+jKIqHIhZCCCGkT7cQQtQrTZs2pVGjRgAUFBRUWS4/P5+XXnqJvn37EhISgo+PD82aNWPChAn89ddflW5z6NAhd9/NQ4cOkZaWxoMPPkjz5s0xGo1EREQwYcIEdu3addYYnU4nX375JWPGjKFJkyb4+PgQFhZGjx49mD59Otu2bTvr9suWLeOaa64hLCwMo9FIu3bteP755yttEgsVByBLSEigb9++BAUFERwczNChQ/nzzz/d5e12O3PmzKFHjx6YTCaCgoIYMWIEGzdurDKmv//+m+nTpzNgwABiYmIwGo2YzWb69OnDyy+/fNb/RdlzmpiYSHp6OtOmTaN169b4+fmdV7L422+/ERgY6D5Xu91+zm0GDRpUbsCrTz75pFwf3TMHwsrLy+OFF16ge/fumEwmfH19iYuL45577uHAgQO1fo6vvPIKR48eBVxN4s9MuM/k5+fHe++9R6dOndzLEhMT3fEAbNq0iZtuuommTZui1+srNOe2Wq3897//ZfDgwYSGhmIwGIiMjGT06NEsWbKkymMfPHiQl19+mauuuorWrVvj7+9PQECA+2bA4cOHK2yTkJCAoijupuXPP/98hX7Thw4dqrDdqlWr+Mc//uG+9oKCgujdu/c5r73acraB1E6/FrKyspg2bRotW7bE19eXmJgY7rvvPjIyMtzlU1JSuOeee9zvM9HR0TzyyCPk5+efNYaMjAyeeuopunXrRlBQEEajkRYtWjBlyhS2b99e5XZHjx7l4YcfpkOHDvj7++Pj40Pjxo3p0aMHDz/8cJUtAYQQ4qxUIYQQXuHZZ59VAfVsb91Hjx51l3nzzTcrLbNp0ya1adOm7nJarVYNDAx0P1YURZ05c2aF7Q4ePOgu89NPP6nh4eEqoPr5+ak+Pj7udSaTSd28eXOlx87IyFAHDhzoLguoZrNZDQgIcD8ePXp0pecdHx+vvvLKK6qiKKqiKKrZbFYVRXFvN3jwYNVut1c45uTJk1VAnTx5svtvnU5X7px1Op26aNEitaSkRB02bJgKqAaDQfX393eX8fPzU9evX1/peZ1+Pn5+fmpwcHC5Ze3bt1fT0tLOuu0HH3ygRkREqIBqNBrd8VV2HmeaN2+eqtfrVUCdPn16pcepzHXXXadGRESoRqPRfdyIiAj3z4IFC9xlt23bVu66OT1GQPXx8VG//vrrizrHs7HZbGpQUJAKqEOGDKn2OZ5p+fLl7ni+/vpr9/NmMplUo9GoxsfHu8seOnRI7dChQ7nXRlkMZT933313pceJj493lzEYDGqjRo1UjUbjXhYUFKSuXLmy3DYLFixQIyIi3DH5+/uX+39ERESohw8fdpd3OBzqAw88UC6egIAAVavVuh+3adNGPXTo0AU/X2U+/vhj9z4PHjx41rIxMTEqoH788ccV1pXt45NPPnFfT/7+/qrBYHCva9eunZqTk6OuXbtWbdSokfv/o9Pp3GX69etX6etdVVV16dKlqtlsdpfV6/XlXssGg0H95JNPKmy3efPmcq9drVarBgcHl3ufqez1J4QQ5yJJtxBCeImzJd12u11dvXq12qtXLxVQw8PD1ZycnArljh075k6Wr7/+enX9+vWq1WpVVVVV09LS1Kefftr9xfa7774rt+3pSXdwcLDar18/dd26daqquhKipUuXqlFRUSqgDhgwoMKxbTab2q9fP3eC9vLLL6vp6enu9ampqep7772nzpgxo9LzNpvNqkajUWfMmKFmZGSoqqqqeXl56jPPPOOO68MPP6xw3LJk1Ww2q76+vup7772nFhUVqaqqqrt27VJ79OihAmpsbKx63333qSEhIeqXX36pWq1W1el0quvXr1dbtmzp/qJfmVGjRqkLFy5Ujx8/7l5WVFSkfvvtt2qbNm1UQL3uuusq3fb0ZKlNmzbqsmXLVIfDoaqqqu7evbvCeZz5pf/VV19134iYPXt2pcc4l7Ml9KqqqhaLRW3evLkKqE2aNFF//vlnd4ybN29W+/Tp4/6/VnbDpbrneDZ//fWXez9vv/32BZ2nqpZPugMCAtQRI0aoO3fudK/fs2ePqqqqWlBQoLZt21YF1EGDBqmJiYlqSUmJqqqqmpubq86aNct9s6iy5/3BBx9U33nnHXXPnj3uc7XZbOqaNWvUq666SgXUxo0bu6/F05Ul7M8+++xZz+Wpp55yv97feecdNSsrS1VVVbVarery5cvVbt26qYDavXt3dwwXqqaTbrPZrHbt2lX9+++/3THPnz9f9fPzUwH1vvvuU2NiYtQrrrhC3bZtm6qqqlpcXKzOmTPHfVPhgw8+qLD/rVu3qr6+viqg3nHHHeqOHTvcyXlKSoo6depU9422svevMkOGDHE/X3/99ZfqdDpVVVXV0tJSdc+ePeprr72mvvLKK+f71AkhhCTdQgjhLU5Puk+v+QoLC3N/CTWZTOpNN91UZc3WbbfdpgLqxIkTqzzOrFmzVEDt0qVLueWnJ91t27atNFn48ccf3WWOHDlSbt3cuXPdtYU///zzBZ13VUnI9ddfrwLq0KFDK6wrSygB9bPPPquwft++feVqCs+sfVRVVV22bFmV53UuR48eVX18fFRFUdSUlJQK68v2azKZzrrvMxNjp9OpPvzww+6au9Nrpc/XuZLul156yV1jmJycXGG9xWJRY2NjVUC95pprKqyv7jmeTdn1A6irVq26oH2oavmku3fv3lXWlr7wwgsquFpYlN2YOtO3336rAmpoaKhqs9mqHYPdblc7d+6sAuq8efMqrK9O0n3w4EFVq9Wqvr6+VbYssVgs7trkM2+ina+aTrojIiLUzMzMCuuffvppd5kOHTq4b3Sc7uabb66yxcMVV1yhAhVu3p2urHXAma1qypL11atXn/X8hBDifEmfbiGE8EJpaWnun4yMDBwOB+AaECsvL4+0tLQK25SUlPDFF18AMH369Cr3PWnSJAC2bNlS6X4AHnnkEXx9fSssv/rqqzEYDMCpEbHLfPTRRwCMGDGCESNGnOsUK/Dx8eHRRx+tdN3o0aMB2Lp1a5XbR0dHM3HixArLW7ZsSatWrQAYMGAA/fv3r1AmPj4eHx+fcx6jMk2aNKFLly6oqnrWOdRvvvlmmjZtWq19Wq1WbrrpJt544w0CAwNZvHgx48ePP6+4zsfChQsBGDt2LB07dqywPjAwkMcffxxwzZ2dl5dX6X7O5xzPlJWV5f47JCTkgvZxpscee6zSqa8APvzwQwCmTZuGXq+vtMyYMWMwmUxkZmayYcOGah9Xq9Vy1VVXAZCUlHSeUbskJCTgcDi46qqr6NKlS6VlAgMDGTNmDAC//vrrBR2nttxxxx3u8SdON3z4cPff06ZNc7/uKitz5mvx0KFD/PHHH+h0uirfK+DUe9zvv//ufu8EMJvNABw/frz6JyKEENUgo5cLIYQXUlW13OOSkhJ27drF22+/zYcffsjSpUtZsGCB+ws3wIYNG9yDjQ0bNqxax0lJSSk3J3iZyy67rNLyOp2OsLAwUlNTyc7Odi+32+3uAYhGjRpVrWOfqUOHDlWOrt24cWOAcsc8U8+ePasctCsiIoJ9+/bRq1evStdrtVpCQ0NJTU0lJyenwnqn08mCBQtYsGABmzdvJiMjo9KB3coGAatMv379qlx3uvz8fK655hp+//13IiIiWLJkCd26davWthfCarW6k5uhQ4dWWe7KK68EXM/Fxo0bGTx4cIUy1T3HS6WqeFJTU0lJSQFgypQpVSbmcGrAwpSUlAqvi5UrV/Lhhx/y999/c/ToUQoLCytsf7Zr4mxWrVoFuAbQi4yMrFZ8dUnv3r0rXX76+01Vr8eyMme+FsueE6fTSfv27as8dlmiXVhYSFZWFuHh4QCMHDmSDz74gMmTJ7Nq1SquvfZaevXqhZ+fXzXPSgghKidJtxBC1ANGo5GuXbsyd+5csrOz+e6777jllls4fPgwJpMJgGPHjrnLV1WDfaayqaTOFBgYWOU2Op3ro8Vms7mXZWVluR/HxMRU69gXcsyzjdhdne3P97zA9RyNHDmS5cuXu5cZDAZCQkLcNaTZ2dnYbLZKk64yZV/8z+Xbb791/71o0aJaTbjBFXtZktKkSZMqy51eg52enl5pmeqeY2VOrxU9282V81FVPKe/VjIzM6u1rzNfK9OnT+eVV15xP9ZqtQQHB7tbghQUFFBYWHjWa+JsymKs7j6qei17SlWvtbLXWXXKnPl6L3tOnE7nBb3HvfLKK+zbt4/ly5cza9YsZs2ahVarpWvXrlxzzTXceeedZ30NCCFEVaR5uRBC1DN33HEH4JreafHixe7lpzejLC4uRnWN63HWnzOnT7pQ9Xme5H//+98sX74cX19f3njjDVJSUigpKSErK4sTJ05w4sQJdw3omS0UTne22tTTxcfHu+div/3228tNr1TXVfccK3P69GCbNm2qiXCqjOf018rOnTur9Vopm5IOYOnSpe6Ee+rUqSQnJ1NaWkp2drb7mnj44YeBs18TZ1MW4/Tp06sVX2Ji4gUdx5uUPScRERHVek5UVSU2Nta9vdls5o8//mDlypU8/vjj9OvXD51Ox4YNG3jhhReIi4tj/vz5Hjo7IYQ3k6RbCCHqmdNrkg8ePOj++/QmqJe6qenptb51rZnrxVqwYAEAzzzzDA899BDR0dEVbjKcOHGixo4XGxtLYmIiMTExbN26lcGDB1dZs1wTQkJC3Mnp2ZpCn77uYmq0q9KzZ0+CgoIA+O6772p8/6e72NdK2TUxfPhw3nnnHTp27Fghwb/Ya6Isxvr2eroYZc9JZmbmBbcgAOjfvz8vv/wySUlJ5Obm8sMPP9CpUyeKi4u57bbbql2LLoQQZSTpFkKIeub05Mff39/9d69evdxNWxctWnRJY9LpdO4+nJf62LXtyJEjAFU28z506BD79u2r0WO2aNGCxMREYmNj2b59O4MGDarRxP50BoOBzp07A7Bs2bIqy/3+++8AaDQaunfvXuNx6HQ67rzzTnccf/75Z7W3dTqd53Ws2NhYdzPiC7lez3VNqKrKH3/8UeX2Go3GXa4qZf3Rf//990rHD2iIyp4Th8PBkiVLamSfRqORa6+91t2to6Sk5IIHvxNCNFySdAshRD1TNkI5uGoHy/j7+7tH73755Zc5fPjwWfdTU/1my0yZMgWAxYsXl2v27u3Kal+3bNlS6fonnniiVo4bGxvLihUraNGiBTt37mTQoEG1NuryhAkTAPj666/Ztm1bhfUFBQXu5tQjRoxwPyc17fHHH3cPmnfjjTeyffv2s5YvLi52N+8+X2XdND788MNzNmc/87Vyrmvif//7HwcOHKhyf2XjMOTm5lZZ5rbbbkOn05GZmcmzzz571visVqt7QLX6LC4uzt0l5p///GeVo+iXOXOwx7PdnDl9toaymyJCCFFd8q4hhBD1xIkTJ3jqqaf45JNPAOjTpw99+/YtV2bmzJk0btyYzMxM+vbty7x588jPz3evz8jI4JtvvuG6667jxhtvrNH4br75Zvr374+qqvzf//0fr776arlBqo4dO8Ybb7xx1unM6qKyqZ9efPFFvv32W/fgTgcPHmTixIl8+eWXBAcH18qxo6OjWbFiBa1atWL37t3Ex8eTmppa48e55557aN68OTabjauvvpolS5a4E5Tk5GSGDx/OwYMH8fHx4cUXX6zx45cJDQ3lm2++wWQycezYMS677DKefPJJtm3b5q4VVlWVXbt28corr9CyZUvefffdC+o3/cgjj9CpUydKSkoYPHgwb7/9drlpy3Jzc1myZAmTJk1iwIAB5bYtuyaWLFnCv/71L3dT59zcXGbOnMn9999f6XRZZcqmZVu8eHGV/8+WLVvy9NNPA64BwCZNmlTuhojdbmfz5s288MILtGrVis2bN5/3c+CN5syZQ0BAAHv27KFPnz788MMP5VoCpKamMm/ePIYMGVLuvebo0aPExcXx4osvsmnTpnKDtG3dupV//OMfgOvmZXx8/KU7ISFE/VALc38LIYSoBc8++6wKqIAaERFR7icoKMi9DlA7deqkpqamVrqfHTt2qK1bt3aX1Wg0akhIiOrv719uH0OHDi233cGDB93rDh48WGWcMTExKqB+/PHHFdZlZGSoAwYMcO9HURTVbDarAQEB7mWjR4+u9Lzj4+OrPOby5cvd259p8uTJKqBOnjy5yu3j4+NVQH322WfP+7wOHTqkRkREuI+v0+nK/T9mzpx51v2XlVu+fHmVxz7XeaSmpqpt2rRRAbVly5bq4cOHz7qv89l3meTkZLVJkybueI1Go2oymdyPfXx81K+++qrSbat7jtW1Y8cOtXv37uWuV51Op4aEhKg6na7c8uHDh6uZmZnubc92rZwpNTVV7dOnT4Xr9fTzBtRWrVqV285qtVa4zoODg1WNRqMC6jXXXKM+9dRTVV7Xe/bsUY1Go/v1GRERocbExKgxMTHqkSNH3OWcTqf69NNPq4qiuI/l6+urNmrUSNVqteViTEpKuvAnXFXVjz/+uFqvf1U9+3vAua6F6rzPnOt/mJSUpEZGRrrLaLVatVGjRqqvr2+55+T222+v9Lhl24SEhKgGg8G9zGAwVHmNCyHE2UhNtxBCeKG0tLRyP0VFRURGRjJ8+HA++OAD1q9f726Ge6Z27dqxdetW3nvvPYYNG0ZoaCgWiwVVVWnVqhU33HAD77//Pl9++WWNxx0aGkpiYiKfffYZV199NWFhYRQWFuLn50ePHj144oknmDlzZo0ftzbFxMSwfv16pkyZ4n7OjUYjI0eO5Ndff2XGjBm1HkPjxo1JTEykXbt27N+/n/j4+BofYKtjx45s376d5557jq5du6LT6SgtLaVly5bcfffdbN++nbFjx9boMavSrl07NmzYwE8//cSUKVNo27YtAQEBWCwWTCYTvXr14uGHH2bDhg388ssvZ61VPpvGjRuTlJTE/Pnzufbaa4mKiqKoqAir1UpsbCyjRo1i9uzZFfqX6/V6fvvtN5599llat26NXq9HVVV69+7Nu+++y48//njWkdzj4uJYvnw51157LWFhYWRlZZGSkkJKSkq5GlhFUXjhhRfYunUrU6dOpV27dmi1WvLy8ggODubyyy/nscceY/Xq1XVujvTa1K9fP/bs2cNrr73GwIEDMZvN5ObmotVqadeuHf/4xz/4/PPPmT17tnubJk2a8OOPP/Lwww/Tp08foqKiKCgoQKfT0b59e+699162bdt2ya5xIUT9oqjqBc5VIYQQQgghhBBCiLOSmm4hhBBCCCGEEKKWeE3S/dlnn3HXXXfRs2dPfHx8UBSFhISESssqinLOn7LpPM4lNja2yn2UjZAphBBCCCGEEEJURufpAKrrqaeeIiUlhdDQUKKios7aV62qqTP27dvH559/Tvv27WnWrFm1jx0UFMRDDz1UYXlsbGy19yGEEEIIIYQQouHxmqR77ty5xMXFERMTw0svvXTWgWmee+65Spfff//9wKm5YqvLbDZXuU8hhBBCCCGEEKIqXpN0Dx069KK2Lykp4fPPP8dgMHDzzTfXUFRCCCGEEEIIIUTVvCbpvljffvstOTk5jB07lrCwsPPatrS0lISEBI4dO+aeiuSyyy6rlTjz8vJITk52P+7UqRNBQUG1ciwhhBBCCCGEELWrwSTdH374IQC33377eW974sQJbr311nLLevXqxfz582nZsmWNxFcmOTmZAQMGuB//8ssv9O3bt0aPIYQQQgghhBCiZgQGBqIoSpXrG0TSffDgQZYvX050dDRXXnnleW176623MmDAADp27EhAQAB79uxh1qxZzJs3jyFDhpCcnExgYGCV28+aNYtZs2ZV+3ilpaXlHl911VXnFa8QQgghhBBCiEsnLy8Pk8lU5foGkXR/9NFHqKrKrbfeikZzfrOknTkSeteuXfn0008BmDdvHh988AHTpk2rcnuLxUJqaur5B33SM888Q9u2bS94eyGEEEIIIYQQteOaa645ayUsNICk2+l0kpCQgEaj4bbbbqux/d51113MmzePVatWnTXpNplMNGnSpNr7LS0tJTMz0/148ODB9OvX76JirWk2m42lS5dy5ZVXotfrPR2OaEDk2hOeJNef8CS5/oSnyLUnPMkbrr/qxFXvk+5ffvmFo0ePMnz4cKKjo2tsv6GhoQAUFhaetdy0adPOmpSfKSkpqVyfbp1OV6cvsLoam6jf5NoTniTXn/Akuf6Ep8i1JzzJ26+/82tr7YUuZgC1s1mzZg0AsbGxNbpfIYQQQgghhBD1R71OujMyMli0aBFhYWFce+21VZaz2Wzs2rWL/fv3l1u+a9cuioqKKpTftWsX06dPB2DixIk1G7QQQgghhBBCiHrDa5qXz507l6SkJAD3PNZz584lMTERgP79+1eozf7000+x2WzcfPPNGAyGKvedmppKu3btiImJ4dChQ+7lCxYsYNasWQwcOJCYmBj8/f3Zs2cPixcvxmazMWPGDAYOHFizJyqEEEKIBsnhcGCz2SpdZ7PZ0Ol0lJSU4HA4LnFk4mLp9Xq0Wq2nwxBCeIjXJN1JSUl88skn5ZatWrWKVatWuR+fmXRfbNPywYMHs3PnTjZt2sTKlSspKioiNDSUESNGMHXqVIYNG3ZB+xVCCCGEKKOqKidOnCA3N/esZSIjIzly5MhZ54IVdZfZbCYyMlL+f0I0QF6TdCckJJCQkHBe2+zYsaNa5WJjY1FVtcLy+Ph44uPjz+uYQgghhBDnoyzhDg8Px8/Pr9KkzOl0UlBQQEBAwHlPfyo8S1VVioqKSE9PByAqKsrDEQkhLjWvSbqFEEIIIeobh8PhTrgbNWpUZTmn04nVasVoNErS7YV8fX0BSE9PJzw8XJqaC9HAyLu2EEIIIYSHlPXh9vPz83AkoraV/Y+r6rcvhKi/JOkWQgghhPAw6edb/8n/WIiGS5JuIYQQQgghhBCilkjSLYQQQgghRBUOHTqEoihs3rwZgMTERBRFOeto80IIcToZSE0IIYQQoh5QHQ6s65JwpJ9AGx6JoVd/FBmwq0q33HILubm5fP/9954ORQhRz0nSLYQQQgjh5Yp//R7LzOk4jqa4l2mbxmB68mV8h4/xXGDnQVVVHA4HOp18PRVC1C/SvFwIIYQQwosV//o9OffeiK5NR0K/XkHk1kxCv16Brk1Hcu69keJfv6+V4w4aNIj77ruP++67j6CgIEJDQ3n66adRVRWAefPm0bNnTwIDA4mMjGTixInuuarhVDPtJUuW0KNHD3x8fEhKSqKwsJBJkyYREBBAVFQUr7/+OoMGDeKhhx5yb6soSoUaarPZTEJCgvvxkSNHGDduHGazmZCQEEaPHs2hQ4cAeO655/jkk0/44YcfUBQFRVFITEwEYO3atXTr1g2j0UjPnj3ZtGlTpee/atUqOnfujNFopE+fPmzbtu2in1MhRP0kSbcQQgghRB2iqirOosIKP2pxxWWOfAuWfz+OT/xwzLMS0LXpCIqCrk1HzLMS8IkfjuXf03HkWyrdZ4VjnEyYq+uTTz5Bp9Oxdu1a3nzzTWbNmsXcuXMB19RY//rXv9iyZQvff/89hw4d4pZbbqmwjyeeeIKXXnqJnTt30rlzZx577DFWrFjBDz/8wG+//UZiYiIbN248r7hsNhvDhw8nMDCQlStXsmrVKgICArjqqquwWq08+uijjBs3jquuuorjx49z/PhxLr/8cgoKChg5ciTt27dnw4YNPPfcczz66KOVHuOxxx7j9ddfZ926dYSFhTFq1CiZDkwIUSlpvyOEEEIIUYeoxUWc6NSo0nXFVWzjSD1MWpewKveZ1jW8WseOTM5C8fOvVlmAZs2a8cYbb6AoCm3atCE5OZk33niDO+64g9tuu81drkWLFrz11lv06tWLgoICAgIC3OteeOEFrrzySgAKCgr48MMP+eyzzxgyZAjgSuybNm1a7ZgAFi5ciNPpZO7cue6puj7++GPMZjOJiYkMGzYMX19fSktLiYyMdG+XkJCA0+nkww8/xGg00qFDB44ePco999xT4RjPPvusO+6yGL/77jvGjRt3XrEKIeo/qekWQgghhBAXpE+fPuXmn+7bty979+7F4XCwYcMGRo0aRXR0NIGBgcTHxwNw+PDhcvvo2bOn++/9+/djtVq57LLL3MtCQkJo06bNecW1ZcsW9u3bR2BgIAEBAQQEBBASEkJJSQn79++vcruy2naj0VjunCpz+vKyGHfu3HlecQohGgap6RZCCCGEqEMUXz8ik7PKLXM6neTnWwgMNKHRnKozKV2XRM5town57BcMXXpV2Jd18zqyb76K4I9+wKdX/2oduyaUlJQwfPhwhg8fzueff05YWBiHDx9m+PDhWK3WcmX9/atfs+6OU1EqNIU/vWl3QUEBPXr04PPPP6+wbVhY1S0ChBB1h1NV2ZlTQorWzM6cEjqG6dCcdpPPm0jSLYQQQghRhyiKUrGJt9OJYneg8fMvl3Qb+w9F2zSGwo/n4PO/r1BOW6c6nRQmzEHbLBZj/6G1Mn3YmjVryj3++++/iYuLY9euXWRlZfHSSy/RrFkzANavX3/O/bVs2RK9Xs+aNWuIjo4GICcnhz179rhrysGVOB8/ftz9eO/evRQVFbkfd+/enYULFxIeHo7JZKr0WAaDAYfDUW5Zu3btmDdvHiUlJe7a7r///rvS7f/+++8KMbZr1+6c5yiEOLtDllL+TM0n6XghBXYnGKL5e3MmAbps+kf5M7BJILEmH0+HeV6kebkQQgghhJdStFpMT75M6R+Lyb77Bqwb/8ZZkI91499k330DpX8sxjTjpVqbr/vw4cNMmzaN3bt3M3/+fObMmcODDz5IdHQ0BoOBOXPmcODAAX788Uf+9a9/nXN/AQEBTJkyhccee4w//viDbdu2ccstt5S70QBwxRVX8Pbbb7Np0ybWr1/P3XffjV6vd6+/6aabCA0NZfTo0axcuZKDBw+SmJjIAw88wNGjRwGIjY1l69at7N69m8zMTGw2GxMnTkRRFO644w527NjB4sWLee211yqN9YUXXmDZsmXuGENDQxkzZsyFP5lCCADeSU7nlyP5roT7NAV2J78cyeed5PQqtqy7JOkWQgghhPBivsPHEPzOfOy7t5F5wyBOdAkj84ZB2PdsJ/id+bU6T/ekSZMoLi6md+/e3HvvvTz44IPceeedhIWFkZCQwFdffUX79u156aWXqkxez/Tqq68yYMAARo0axdChQ+nfvz89evQoV+b111+nWbNmDBgwgIkTJ/Loo4/i53eqabyfnx9//vkn0dHRXH/99bRr144pU6ZQUlLirvm+4447aNOmDT179iQsLMw9wvmiRYtITk6mW7du/POf/+Tll1+uNM6XXnqJBx98kB49enDixAkWLVqEwWC4wGdSCAGuJuWFNiexAQYmtw12L5/UKoh7OoYSG2Cg0O7EeZ4zLXiaNC8XQgghhPByvsPHYBw6Cuu6JBzpJ9CGR2Lo1b/WarjL6PV6Zs+ezbvvvlth3Y033siNN95Ybtnp/bAHDRpU6RRlAQEBzJs3j3nz5rmX/fzzz+XKNG7cmF9//bXcstzc3HKPIyMj+eSTT6qMPSwsjN9++63C8j59+rB58+ZqxT1y5Mgq9y+EOH+7ckrItTp5uGsjTAYNn5ADQM9wI6EBfkT46Xlu7XF25ZTQPsTXw9FWnyTdQgghhBD1gKLV4tMn/twFhRCijsotdY2zsCunhEUHctzLd+RaGRjgR7MAQ7ly3kKSbiGEEEIIIYQQHuVUVY4WuGY3mL83p9y69mZXsn3k5HqzT+224qlpknQLIYQQQojzlpiYWC+PJYS4tFRVZWtWMQv25pCS70qqdRoY28LMgn25gGtWB6eq8uPBPMJ8dbQNNnow4vMnSbcQQgghhBBCiEtuX14pC/ZksyOnBABfnUKcyYet2SUknShwl/s5pYBdudkcKrByU1yw183XLUm3EEIIIYQQQohL5nihjYX7slmbVgSAToFh0SZGNzfzxuY0AI4W2N3lfzl6KgHfkFHENc3NlzTeiyVJtxBCCCGEEEKIWpdTaufb/bksT83HqYICDGgcwP+1NBPmqwdgUttGHC20oqpw1FLCzv0HadeyOU1NRhQFmvp739R8knQLIYQQQgghhKg1RTYniw7lsiTFgtXpmnKvW6gv4+NCiA4sn0THmnyINfkAYAszsnj3cUa07IZer7/kcdcUSbqFEEIIIYQQQtQ4q8PJ0iP5/HAwlwKbE4C4IB9ubB3idYOhXQxJuoUQQgghhBBC1BinqpJ0rICv9+eQWeKaU7uJv57xccH0CPND8bKB0C6WJN1CCCGEEEIIIS6aqqpsyixm4d5sjhTYAAjx0TK2VTADogLQahpWsl1Gkm4hhBBCiHpAdTqwpq/EUXQcrV8UhvABKBqtp8MSQjQQe3JLmL8nm925pQD46TSMbh7E8GgTBq3Gw9F5liTdQgghhBBerjjlWyzrH8FRcMi9TBsQi6nn6/jGXO+5wGqYzWarMJiS1WrFYPC+0YyFqC+OFlhZuDeHDRmu6b/0GoWrok2Mah5EgF5u/AE07FsOQgghhBBerjjlW3ISx6IzdyJ0xF9ETswndMRf6MydyEkcS3HKt7Vy3EGDBnHfffdx3333ERQURGhoKE8//TSqqvLCCy/QsWPHCtt07dqVp59+GoB169Zx5ZVXEhoaSlBQEPHx8WzcuLFceUVRePfdd7n22mvx9/fn3//+N8899xxdu3Zl7ty5NG/eHKPRNRjT4cOHGT16NAEBAZhMJsaNG0dammu+37y8PLRaLevXrwfA6XQSEhJCnz593Mf67LPPaNasWa08V0LUR1kldt7fnsH01alsyChCAQY3CWBW/6bc2DpEEu7TSNIthBBCCFGHqKqK01ZY4Ue1V1zmKLVgWTcNnyZXYx7wOTpzJ0BBZ+6EecDn+DS5Gsu6R3CUWirdZ4VjqOp5xfrJJ5+g0+lYu3Ytb775JrNmzWLu3Lncdttt7Ny5k3Xr1rnLbtq0ia1bt3LrrbcCkJ+fz+TJk0lKSuLvv/8mLi6OESNGkJ+fX+4Yzz33HNdddx3JycncdtttAOzbt49vvvmGb7/9ls2bN+N0Ohk9ejTZ2dmsWLGCpUuXcuDAAcaPHw9AUFAQXbt2JTExEYDk5GQURWHTpk0UFBQAsGLFCuLj4y/kXyZEg1Jgc/DFnmymJR0lMbUAFegV7scrlzfhjg5hNDJKY+ozyTMihBBCCFGHqPYiTnwRUOm64iq2cRSmkDbfVOU+0xYEVevYkRMLUPT+1SoL0KxZM9544w0URaFNmzYkJyfzxhtvcMcddzB8+HA+/vhjevXqBcDHH39MfHw8LVq0AOCKK64ot6/3338fs9nMihUrGDlypHv5xIkT3Yl6GavVyqeffkpYWBgAS5cuJTk5mYMHD7prqz/99FM6dOjAunXr6NWrF4MGDSIxMZFHH32UxMRErrzySnbt2kVSUhJXXXUViYmJPP7449U+dyEaGqvDyS+HLfx4MI8iu2v6r7bBRibEBdPa3HCm/7oQUtMtvEZeXh5JSUnun7y8PE+HJIQQQjRoffr0KTf1T9++fdm7dy8Oh4M77riD+fPnU1JSgtVq5YsvvnDXVAOkpaVxxx13EBcXR1BQECaTiYKCAg4fPlzuGD179qxw3JiYGHfCDbBz506aNWtWrnl4+/btMZvN7Ny5E4D4+HiSkpJwOBysWLGCQYMGuRPxY8eOsW/fPgYNGlRTT40Q9YbDqbL8aD7Tko6yYG8ORXYnzQL0PNYtgqd7RkrCXQ1S0y28RnJyMgMGDHA//uWXX+jbt68HIxKXms1mo6ioCIvFUmEgHSFqmyevv8DAwAY3p2lDpuj8iJxYUG6Z0+kkP99CYKAJjeZUnUlp2p/kLBtByLA/MIT2rrAva8YaspcOIXjIYnwiBlbr2DVl1KhR+Pj48N1332EwGLDZbIwdO9a9fvLkyWRlZfHmm28SExODj48Pffv2xWq1ltuPv3/FmvfKlp3LwIEDyc/PZ+PGjfz555/MnDmTyMhIXnrpJbp06ULjxo2Ji4s7/xMVop5SVZX16UUs3JfDsULX9F+hRi03tAqmX1QAGvlcqjZJuoXXuuqqqzwdghBCXBJ5eXmYTFU3HRb1i6IoFZt4O50oOgcavX+5pNvYeBjagFgKd7yBzxXfoyin1qmqk8Kds9EGNMfYeFitTB+2Zs2aco/L+mZrta5jTZ48mY8//hiDwcCECRPw9fV1l121ahX//e9/GTFiBABHjhwhMzPzguJo164dR44c4ciRI+7a7h07dpCbm0v79u0BMJvNdO7cmbfffhu9Xk/btm0JDw9n/Pjx/PTTT9KfW4jT7MwuZv7eHPbluab/CtBrGNPCzNCmgQ1++q8LIUm38FrnW9Nts9n47bffGDZsmFfWkkr8nuXN8Xtz7CDxg6umW4jKKBotpp6vk5M4luw/xhDYaQa64I7Yc7aRn/wfSo/+RPCgr2ttvu7Dhw8zbdo07rrrLjZu3MicOXN4/fXX3etvv/122rVrB7iS7NPFxcUxb948evbsicVi4bHHHiuXlJ+PoUOH0qlTJ2666SZmz56N3W5n6tSpxMfHl2uePmjQIObMmeOucQ8JCaFdu3YsXLiQd95554KOLUR9cjjfyoK92WzOdI0g4aNRuDo2iJExQfjpJdm+UJJ0C6/l7+9/XjU/NpsNPz8/TCaT135xl/g9x5vj9+bYwXvjtzqcrEkrZF2ajcPmDhw/bKNXhIHLIvyllkDUKN+Y62HQ11jWP0Lmksvdy7UBzQke9HWtztM9adIkiouL6d27N1qtlgcffJA777zTvT4uLo7LL7+c7OxsLrvssnLbfvjhh9x55510796dZs2aMXPmTB599NELikNRFH744Qfuv/9+Bg4ciEaj4aqrrmLOnDnlysXHxzN79uxyfbcHDRrEli1bpD+3aNAyim18tS+XVcddo5FrFRjcJJDrWpoJ9pGU8WLJMyiEEELUsA3phby/PZN8m5PWQQZ8VAcWq4N3t2Xy2e5s7uwQRo/wmus7K4RvzPUYm43Gmr4SR9FxtH5RGMIH1FoNdxm9Xs/s2bN59913K12vqirHjh1j6tSpFdZ169at3JRiQLk+32Xbn+m5557jueeeq7A8OjqaH3744azxjhkzpsI+Z8+ezezZs8+6nRD1lcXq4IcDuSw9YsF+8qXRJ8KfG1oFE+XvPTe66zpJuoUQQogatCG9kFmb0+ke5sfE1iGEGmDx4vWM6N6RTCt8sSebWZvTmNY1nB7h5z8YlBBVUTRafCIHeToMt4yMDBYsWMCJEycqTPklhPCsEruTJYfz+OlQHsUns+0OIUZujAuhRZCPh6OrfyTpFkIIIWqI1eHk/e2ZdA/z4+Gu4WgUBZvN5l4f5a/n4a7hvLE5nfe3ZzKnka80NRf1Vnh4OKGhobz//vsEBwd7OhwhBGB3qixPzee7/bnkWh0AxAYamBAXTKdGvjJTRi2RpFsIIYSoIWvSCsm3OZnYOqTcVCrFp33cahSFG1sH8+iqVNamFdG/cYAnQhXioiUmJp51fWVNw4UQnqGqKmvSClm4L4e0IjsA4b46xrUKpk+kv0z/Vcsk6RZCCCFqyPr0ItqYfdz94OxOlc/25JJobEO/IhvNglzLG/sbaG32YV16oSTdQgghatW2rGIW7M3mgMUKgMmg4boWwQxpGohOI8n2pSBJtxBCCFFDiuxOgo2uj9bcUjtvbUlnV24pKFq255TSLOjU4GkhPjrybQ5PhSqEEKKeO2QpZf7eHJKzXNN/GbUKI2ODuDomCF+ddG26lCTpFkIIIWqIn05DTomdvbklzN6STk6pA1+tQo+igwxp0r9c2exSO0GG2h1ZWgghRMOTVmTjy305/HWiEHBN/zW0mYkxzc0E+cjnjidI0i2EEELUkJ7hfry7LZPn1x7HCTTx13N/xxA2JW4pV+5YoZU9uaVM7RjmmUCFEELUO3mlDr47kMuyoxYcJ4dUuDzSNf1XhJ9M/+VJknQLIYQQNcDqcLI929WEzwn0CvPl7k7h6FQHm04r51RV5u/JIVCvoXeEzNUthBDi4hTbnfx8KI+fU/IoPZltd2nky/i4YGJNMv1XXSBJtxBCCHGRskrszN6czn5LKQAKrsQ7t9RBqOFUuWOFVubvyWFjRhHTukbIdGFCCCEumM2psuyIhe8P5GKxOQFoYTJwY+sQOoT4ejg6cTpJuoUQQoiLsDO7mDe3pGOxOfHXabi/cxg2p8r72zN5ZNVR4oIMlOij2bgxnb15VgL1GqZ1jaBHuNRyi4Zt0KBBdO3aldmzZwMQGxvLQw89xEMPPeTRuISo65yqyl8nCvlyXw4Zxa7pv6L89IxrFUzvCD+Za7sOkqRbCCGEuACqqvLLYQuf78nGqUJMoIGHu4QTfrLf3JxGvqxNK2JtWgF5ipYIg5apHcPoHeEnNdyiVjhVlV05JeSWOjD7aGkbbPSquXfXrVuHv7+/+7GiKHz33XeMGTPGc0EJUYeoqsrWrGIW7M0hJd81/ZfZR8v/tTAT30Sm/6rLJOkWQgghzlOpw8ncHZmsOu4aGbZflD+3tw/F57Rk2qDV0L9xAJeF+bD48BpGdGyHXi8D2YjasTatkM93Z5NRYncvCzPquKlNCL0j/M+yZd0RFiYDCwpRlX15pSzYk82OnBIAfHUKo2LNXBVtwijTf9V58h8SQgghzkN6kY3n1h5n1fFCNArc3CaEqR3DyiXcQlxKa9MKeXNLOs0CDTzfO4qProjh+d5RNAs08OaWdNamFdbasb/++ms6deqEr68vjRo1YujQoRQWFuJwOJg2bRpms5lGjRrx+OOPM3ny5LPWWsfGxpZrag5w3XXXoSiK+zHADz/8QPfu3TEajbRo0YLnn38eu91ecYdC1APHC23M3pLGM2uOsSOnBJ0CI2JMzO7fjDEtzJJwewmv+S999tln3HXXXfTs2RMfHx8URSEhIaHSss899xyKolT5c+jQofM69p49exg3bhyhoaH4+vrSpUsX3n33XVRVvfgTE0II4TW2Zhbxz7+PkZJvxWTQ8M8ekVwdEyT950SNUlWVEruz/I/DSalDpcRRfnmRzcFnu7PoEurL1I6hNAtwjdzXLMDA1I6hdAn15bPd2RTZHBX3WcnP+Xy3OX78ODfeeCO33XYbO3fuJDExkeuvvx5VVXn99ddJSEjgo48+IikpiezsbL777rtq73vdunUAfPzxxxw/ftz9eOXKlUyaNIkHH3yQHTt28N5775GQkMC///3v83iGhaj7ckrtfLgjk8dWH2VtWhEKMLBxAK/3b8o/2jQi0CDzbXsTr2le/tRTT5GSkkJoaChRUVGkpKScc5vJkyeXuzNaxmw2V/u4O3bs4PLLL6e4uJhx48bRuHFjfv75Z6ZOncqOHTuYM2fOeZyFEEIIb6SqKj8ezOPLfTmoQEuTDw91DaeR0Ws+RoUXKXWo3PZHVd9zcitdmllSzO3LD1e5z7OtO91HV8Rg1FXvJtLx48ex2+1cf/31xMTEANCpUycAZs+ezYwZM7j++usB+N///sevv/5arf3CqabmZrOZyMhI9/Lnn3+eJ554gsmTJwPQokUL/vWvf/H444/z7LPPVnv/QtRVRTYniw7lsiTFgtXpugnWLdSX8XEhRAcazrG1qKu85tvC3LlziYuLIyYmhpdeeokZM2acc5tbbrmFQYMGXdRx77nnHvLy8li8eDFXX301AP/6178YOnQob7/9NhMnTqRv374XdQwhhBB1V7Hdyf+2ZbAuvQiAwU0CuKVdKHoZsEY0cF26dGHIkCF06tSJ4cOHM2zYMMaOHYtGo+H48eNcdtll7rI6nY6ePXtedCvBLVu2sGrVqnI12w6Hg5KSEoqKivDzk1kBhHeyOpwsPZLPDwdzKTg5/VdckA83tg6hbbDRw9GJi+U1SffQoUMv+TH37NnDn3/+yeDBg90JN4DBYOBf//oXgwYN4oMPPpCkWwgh6qljhVbe2JxOaqENrQK3tGvEkKYmT4cl6jkfrcJHV8SUW+ZUneRb8gk0BaJRTvUO3JVTwiub0vhnj0haBvlU2Ne+vFJmbjjB490iqvXF3Udb/ZtJWq2WpUuXsnr1an777TfmzJnDP//5T5YuXVrtfZyvgoICnn/+eXcN+umMRklMhPdxqipJxwr4en8OmSUOAJr46xkfF0yPMJn+q77wmqT7Qvz555+sWbMGjUZDXFwcQ4cOJSAgoNrbJyYmAjBs2LAK6/r374+/vz8rVqyoqXCFEELUIRvSC/nvtgyK7SrBPloe6hJOnFm+1IvapyhKhSbeTidYtQpGrQaN5lTS3TnUlzCjjiWHLUzrGl5uijDnyWntwnx1dA71rZXpwxRFoV+/fvTr149nnnmGmJgYli1bRlRUFGvWrGHgwIEA2O12NmzYQPfu3au9b71ej8PhKLese/fu7N69m1atWtXoeQhxqamqyqbMYhbuzeZIgQ2AEB8tY1sFMyAqAK20pqpX6nXSfWbfHrPZzJtvvsmkSZOqtf3evXsBiIuLq7BOq9XSvHlzduzYgd1uR6er10+lEEI0GE5V5dv9uXx7IBeAtmYfHugSjtlH3udF3aNRFG5qE8KbW9KZtTmda5sH0SzAwJECKz8ezGNTRhEPdgmvlYR7zZo1LFu2jGHDhhEeHs6aNWvIyMigXbt2PPjgg7z00kvExcXRtm1bZs2aRW5u7nntPzY2lmXLltGvXz98fHwIDg7mmWeeYeTIkURHR7ubsm/ZsoVt27bx4osv1vg5ClEb9uSWMH9PNrtzSwHw02kY3TyI4dEmDDITRr1UL79BdOnShY8++ohBgwYRFRXFiRMn+Omnn3jmmWe45ZZbMJvNXHvttefcT15eHgBBQUGVrjeZTDidTvLz8wkODq60zKxZs5g1a1a1Yy8tLS332G63Y7PZqr39pVAWz6WOS6YDEULUtkKbg3eSM9icWQzA8GgTN7UOQefBGoe69hkgapbNZkNVVZxOJ06ns8pyZX2hy8qermeYLw90DuOLPdk8t/a4e3mYr44HOofRM8z3rPu+UAEBAaxYsYLZs2djsViIiYnhtddeY/jw4QwZMoRjx44xefJkNBoNt956K2PGjCEvL69cLGeez+mPX331VR599FE++OADmjRpwoEDB7jyyiv58ccfefHFF3n55ZfR6/W0bduW2267rVbOsSY5na7R4W02G1qt94w87anvffVRaqGNrw/ksTHTNde2XgPDmgZyTXQg/noNOB3YnI5z7KVh8YbrT6/Xn7NMvUy6r7vuunKPY2Njue+++2jXrh1XXnklTz31VLWS7ppgsVhITU294O3/+usvd/Jf19Rmn63K7Nix45IeTwjRsBzJtzJrcxppxXb0GoXb2zdiQONAT4fF4sWLPR2CqEU6nY7IyEgKCgqwWq3nLJ+fn1/p8jZGeLZTIPvy7eTZVIL0Cq0CdWgUOxaLpabDBqBJkyYsXLiwwvKy4z3//PM8//zz7uVTp07Fbj8Vz/fff1+u/ObNm8s9jo+Pd08Vdvryvn378vPPP1d53LrKarVSXFzMn3/+6ZUVCZf6e199UqTo2aaL4JA2GFVRUFSV5o5sOtjS8dttY8VuT0dY99Xl62/06NHnLFMvk+6qDBkyhJYtW5KcnIzFYsFkOvtgOGU13FUlvRaLBUVRCAys+kuZyWSiSZMm1Y6xtLSUzMxM9+O+ffvSr1+/am9/KdhsNpYuXcqVV15ZrTs7NaWqFgdCCHGx/j5RwHvbMil1qoQadTzcNZzmpoqDUnnCiBEjPB2CqEUlJSUcOXKEgICAsw4Epqoq+fn5BAYGnnVgpZ51+KNSr9ej0+nO+f2rviopKcHX15eBAwd61aBvnvreVx8U2Jz8nGJhaWoBJwckp0eokbEtgmjs38yzwXmJ+nL9NaikGyA0NJR9+/ZRVFR0zjf9sr7cZX27T+dwODh48CDNmzc/a3/uadOmMW3atGrHl5SUxIABA9yPdTpdnb3A9Hr9JY1N+s0LIWqaw6myYG8OP6e4bq52DDFyf+dwAg11p+lnXf0MEDXD4XCgKAoaTfkB0s5U1nS6rKw3UhTFq+O/WBqNBkVRLvn3p5rirXF7gtXh5JfDFn48mEeR3fXabRtsZEJcMK1lQM4L4u3XX4PKYgoLC9m+fTv+/v6Ehoaes3x8fDwAv/32G0888US5dUlJSRQWFrrLCCGE8C4Wq4M5W9PZnu3qWzcqNojxccG1MuCUEAISEhI8HYIQtcrhVPnzWAHf7M8hu9TVN7tZgJ4JcSF0DfWV6b8asHqXdOfn53P8+HFat25dbnlxcTF33HEH+fn53HrrrRVqTXft2gVA27Zt3cvatGnDwIEDWb58OUuWLHHP1W21Wnn66acBuP3222vzdIQQQtSCg5ZS3ticRmaJAx+twl0dwugT6e/psIQQQnghVVVZn17Ewn05HCt0DfgVatRxQysz/aIC5Gau8J6ke+7cuSQlJQGQnJzsXlY2l3b//v25/fbbycrKom3btvTq1Yt27doRGRlJWloav//+O0ePHqVTp068+uqrFfbfrl074NTooGX++9//0q9fP8aMGcP48eOJiori559/Zvv27dx3331cfvnltXjWQgghatqfx/L5cEcWNqdKhJ+OaV0iaBZo8HRYooE78/uHqH/kf1w/7cwuZv7eHPbluWYgCtBruK6FmaHNTOhlrm1xktck3UlJSXzyySfllq1atYpVq1a5H99+++2EhIQwdepU1q5dy+LFi8nJycHX15d27drxwAMPcN999+Hr61vt43bo0IE1a9bw1FNP8fPPP1NYWEjr1q155513uOeee2rs/IQQQtQuu1Nl3u4slh5xjf7cLdSXqZ3C8NfXnf7bouEp66NYVFR0Xt9PhPcpKioCZJyG+uJwvpUFe7PdU0z6aBSujg1iZEwQfvqGOW6BqJrXJN0JCQnV6gtkMpl4++23z3v/Z7v72KZNG7766qvz3qcQQoi6IbfUzptb0tmd66qJuL6FmetbmqXJn/A4rVaL2WwmPT0dAD8/v0r7fTqdTqxWKyUlJQ12IDJvpaoqRUVFpKenYzabvWqOblFRRrGNr/blsup4ASqgVWBwk0Cua2km2MdrUitxicmVIYQQol7bk1vC7C3p5JY68NUp3NspnO5hfp4OSwi3yMhIAHfiXRlVVSkuLsbXVwZj8lZms9n9vxbex2J18MOBXJYesWA/WVfXJ8KfG1oFE+UvrRfE2UnSLYQQol5SVZVlR/P5ZFcWDhWa+OuZ1jVCvhyJOkdRFKKioggPD8dms1Vaxmaz8eeffzJw4EBpnuyF9Hq91HB7qRK7kyWH8/jpYB7FDle23SHEyI1xIbQI8vFwdMJbSNIthBCi3rE6nCTsyiIxtQCA3hF+3N0hDKNOmuWKukur1VaZmGm1Wux2O0ajUZJuIS4Bu1NleWo+3+3PJdfqmv4rNtDAhLhgOjWSFifi/EjSLYQQol7JKrHzxuY0DlisKMCEuGBGxgbJFyQhhBDn5FRV1qYVsnBfDmlFdgDCfXWMaxVMn0h/GQtEXBBJuoUQQtQbO7KLeWtLOhabkwC9hvs7h9OpkYwILYQQ4ty2ZRWzYG82ByxWAEwGDde1CGZI00B0Mv2XuAiSdAshhPB6qqqy5LCFL/Zk41QhJtDAw13CCfeTZrhCCCHO7pCllPl7c0jOck3/ZdQqjIwN4uqYIHylW5KoAZJ0CyGE8GqlDicfbM9k9YlCAPpH+TOlfSg+WvmiJIQQomppRTa+3JfDXyc/P7QKDG1mYkxzM0E+MvCdqDmSdAshhPBaaUU23ticzuECK1oF/tEmhGHNTNJ/WwghRJXySh18dyCXZUctnByQnMsjXdN/RUgLKVELJOkWQghRJ1kdTtakFbIurZDDhubs35ZFrwh/Lovwx6DVsCWziLe3ZlBod2IyaHiwczjtQqT/thBCiMoV2538fCiPn1PyKD2ZbXdp5Mv4uGBiTTL9l6g9knQLIYSoczakF/L+9kzybU5aBxnwUR1YrA7e3ZbJZ7uz6RLqy6rjhahAqyAfHuoSTohRPtKEEEJUZHOqLDti4fsDuVhsTgBamAzc2DqEDnKzVlwC8g1FCCFEnbIhvZBZm9PpHubHxNYhhBpg8eL1jOjekSPFTl7bmEbScVf/uyuaBjK5bSP0MqqsEEKIMzhVlb9OFPLlvhwyil3Tf0X56RnXKpjeEX7SFUlcMpJ0e6GCggKOHTuGr68vzZo183Q4QghRY6wOJ+9vz6R7mB8Pdw1HoyjYbDYAjhfZ+O+2bHKtDhTAR6swqU2IJNxCCCHKUVWVrVnFLNibQ0q+a/ovs4+W/2thJr6JTP8lLj1Jur2E0+nkk08+4b333mPr1q0EBwdTUlKCRqPhuuuu45FHHqFNmzaeDlMIIS7KmrRC8m1OJrYOQXNaDUSqxsQP69MpcaiE+Gj5R+sQ3krOYG1aEf0bB3gwYiGEEHXJvrxSFuzJZkdOCQC+OoVRsWauijZhlOm/hIdI0u0l+vbtS79+/Xjrrbfo0aMHWq1rGoP09HR++eUX7rjjDqZOncqECRM8HKkQQly49elFtDH7EOXvGj3Wqap8eyCPJJ9YcKi0DTbyYOdwgny0/HLEwrr0Qkm6hRBCcLzQxsJ92axNKwJAp8CwaBOjm5sJNMj0X8KzJOn2EosWLSI8PLzC8vDwcCZNmsSkSZNIT0/3QGTV8+abbzJr1izS0tLo2bMn77zzDl26dPF0WEKIOqbI7iT45IBohTYH/03OYFNmMQDDmgbwj7ah7maBIT468m0Oj8UqhBDC83JK7Xy7P5flqfk4VVCAAY0D+L+WZsJ8ZfovUTdI0u0lKku4L6SMJ3zxxRdMnz6d999/nx49evDqq68yfPhw9uzZg8lk8nR4Qog6xE+nIafEztECK7M2p3GiyI5eA91LDnNT3OXl+uFll9oJktoLIYRokIpsThYdymVJigWr0zX9V7dQX8bHhRAdaPBwdEKUJ0m3lxk8eHCFkRbNZjN9+/blgQcewMen7s0x+MYbb3D33XczadIkAObOnUtkZCRffPEFd999t4ejE0LUJT3D/Xh3WyZP/Z2K1QmhRi33d2zEjpVby5U7VmhlT24pUzuGeShSIYQQnmB1OFl6JJ8fDuZScHL6r7ggH25sHULbYKOHoxOicjKagJfp0aMHOp2OKVOmcPvtt2MwGGjcuDHr16/n/vvvv6B9fvbZZ9x111307NkTHx8fFEUhISHhrNvs3buXa6+9FrPZjL+/P3369OHLL7+sUM5qtbJp0yaGDh3qXqbT6Rg0aBB//fXXBcUrhKifnKrK0QLXSOVWJ7Qz+/BinybEnlFj4VRV5u/JIVCvoXeEnydCFUIIcYk5VZU/U/N5ZNVRPt+TTYHNSRN/PdO6hvNc7yhJuEWdJjXdXmb16tWsXLnSPZDaDTfcwIABA0hKSqJTp04XtM+nnnqKlJQUQkNDiYqKIiUl5azlExMTmTFjBr6+vkyYMIHAwEC++eYbxo8fz5EjR3jkkUfcZTMzM3E4HERERJTbR3h4OPv377+geIUQ9U+hzcE7yRlsPtl/G8BXr6HQ5sT3tJz7WKGV+Xty2JhRxLSuERi0cu9YCCHqM1VV2ZRZzMK92Rw5eWM2xEfL2FbBDIgKQCvTfwkvIEm3l8nKyirXvFxRFHJyctDpdBiNF3aHb+7cucTFxRETE8NLL73EjBkzqixrt9u55557UBSFZcuW0atXLwCeeeYZevfuzZNPPsnYsWOJiYm5oFiEEA3P0QIrr29OI63Ijl6jcEf7UHx1Cu9vz+SRVUeJCzJQoo9m48Z09uZZCdRrmNY1gh7hUssthBD12Z7cEubvyWZ3bikA/joN1zYPYni0SW66Cq8iSbeXGTJkCFdffTX/+Mc/ANcgZVdccQUFBQUX3J/79Kbf5/LHH3+wf/9+hgwZQteuXd3Lg4KCePLJJ7nlllv45JNPeOaZZwAIDQ1Fq9WSlpZWbj/p6elERkZWeozCwsJKlxcXF1e6XAjhvdamFfK/bRmUOFRCjToe7hpOc5PrvWxOI1/WphWxNq2APEVLhEHL1I5h9I7wky9bQghRjx0tsLJwbw4bMlzTf+k1CldFmxjVPIgAvQygKbyPJN1e5q233uK9997j+++/B2DkyJHcdddd6HQ6/v7771o/fmJiIkC5hLvM8OHDAVixYoV7mcFgoFu3bixbtoyRI0cCrtryxMREXnzxxUqPERBQvTl37XY7Nput2rGXlT2fbeoSid+zvDn+uhi7U1X59qCFRSn5ALQ3+zC1QwiBBo07TgW4LMyH7mYNSw+v4co2rdDr9eB0YHN6z1RhF/v86/Uy5Y0QomHIKrHzzf4cVqQWoOL6HBjUJIDrWwbTyChpi/BecvV6GZ1Ox7333svUqVMBKoxkXtv27t0LQFRUVIV1kZGRBAQEuMuUefjhh5kyZQo9evSge/fuvPbaa+h0OiZOnHhRsfz111/k5eWd93ZLly69qON6msTvWd4cf12J3YqGvw3RHNe6pgxsbc+gw/HjrDx+9u3qSvwX6kLjHz16dA1HIoQQdUuBzcGPB/P49bAF28npv3qF+zGuVTBNAmT6L+H9JOn2MseOHeP2229n+fLlgKu5+QcffFBpElwbypJcf3//StebTKYKifDEiRPJyMjgySefJC0tjZ49e/Lrr79WOUd3QUFBpctXr17NsGHD3I/79u1Lv379qh27zWZj6dKlXHnllV5ZcyTxe5Y3x1+XYj9aaOOt5CzSil3zb9/WJoTLI5sC3arcpi7FfyG8PX4hhKgtVoeTXw5b+PFgHkV21/RfbYON3BgXTJxZRiMX9Yck3V7mrrvuon///nzxxRcA/O9//+POO+9k0aJFHo7s7B588EEefPDBapWtKqH39fUt91in013QF1i9Xu/VX3wlfs/y5vg9HfvatELe3ZZB6cn+29O6hhNrqv5YFJ6O/2J5e/xCCFFTHE6VP48V8M3+HLJLXd2FmgXomRAXQtdQ30veklOI2iZJt5c5cuRIuQT7iSeeqLR/dW0JCgoCqh7szGKxEBwcfMniEULUfU5V5ct9Ofx40NUKpkOIkfs7h2MyyGA4QgjRkKiqyvr0Ihbuy+FYoWuci1CjjhtamekXFYBGkm1RT0nS7WVUVeXEiRPukb9PnDiBqqqX7PhxcXEAHD9esfPliRMnKCgooHfv3pcsHiFE3VZwcv7tLSfn3x4RY+LGuBCZV1UIIRqYndnFzN+bw7481/RfAXoN17UwM7SZCb18Joh6TpJuL/Poo4/SrVs3rr76agB++eUXXn311Ut2/Pj4eP7zn/+wefPmCut+/fVXdxkhhDiSb2XW5jTSiu0YNAp3dAilX1T1ZieoD9TSEooXf0PRrz/Q5tAB8pZ8jt/w0fiO+D8UH+mrKIRoGA7nW1mwN5vNJ2+++mgUro4NYmRMEH56mf5RNAySdHuZm2++mW7durmn7nrkkUfo0KHDJTv+kCFDaNGiBX/++SebN2+mV69egGuAtZkzZ2IwGJg0adIli0cIUTetOVHI/7ZfeP9tb1fy+0/kzrgbZ3Ymuh59sfkH4szOIPfRKVhmTsf80nsYh1zj6TCFEKLWZBTb+GpfLquOu6b/0iowuEkg17U0E+wjKYhoWOSK90IdO3akY8eONba/uXPnkpSUBEBycrJ7WVli379/f26//XbANXjZ//73P0aMGMGQIUOYMGECgYGBfPPNN6SkpPDaa68RGxtbY7EJIbyL9N92JdzZ94zDeMU1mJ6Yido0lr8WL6btiBEoRw9heelJsu++gZB3v8Q4dKSnwxVCiBplsTr44UAuS49YsJ/sAdknwp8bWgUT5S+DSYqGSZJuL9GtW7ezjuS4cePGC953UlISn3zySbllq1atYtWqVe7HZUk3wKBBg5g5cybLli1j4cKF2Gw2OnXqxMsvv8z48eMvOA4hhHcrsDl4Z2sGW7JcTQiviTExoYH131ZLS8idcTfGK64h+L8LULRabDabe72ueRzB/11AztQJ5M64m4gB+6SpuRCiXiixO1lyOI+fDuZR7HBl2x1CjNwYF0KLoIbT0kmIykjS7SVmz55da/tOSEggISHhvLZp3bo1Dz30kEx/I4QApP92meLF3+DMzsT0xEwU7anafV1+nvtvRavFNP3fpF/ZmeIl3+I3ZqInQhVCiBphd6osT83nu/255Fpd03/FBhqYEBdMp0Yy/ZcQIEm315DByYQQddXfJwp572T/7TCjjocbWP/t05UsXYSh5+XomrtmelDtdgpe+Sed5n+Io+9l6Fu2AUDXojWGHn0p+e1HSbqFEF7JqaqsTStk4b4c0orsAIT76hjXKpg+kf4y/ZcQp5Gk20tMnTqVJ598kqZNm1ZYp6oq3377LaWlpUycKF/ehBCXRmX9tx/oHE5gA+q/fSanJRdNRBMAHJmpZL4yAodmG7qxKnkrx+PkEXxjb0DRGtFENMGZk+nhiIUQ4vxtyypmwd5sDlisAJgMGq5vEcwVTQPRNaAuRUJUlyTdXmLEiBGMGDGC4OBgLrvsMiIiIigpKWH37t2sWrWKESNG8MILL3g6TCFEA1Fgc/D21gy2uvtvBzEhLrhB9d+ujMZkxpmWSsGqN7EkPwIdHHBUR35wK4LDA8hNmoRl3TTM/T7CmZaKJjTC0yELIUS1HbKUMn9vDskn3/uNWoWRsUFcHROEr06m/xKiKpJ0e4mRI0cycuRIkpKSSExMZO/evfj5+XHFFVcwa9YsQkNDPR2iEKKBOHyy/3b6yf7bd3YI5fIG2H+7MsYrR5H7/i1Y9yyHFA2aHS0I+vc3rNufwogrR6AUHcSy4XGy/xgD+RrMEz855z6FEMLTChQD/92exZp0V7KtVWBoMxNjmpsJ8mm4rZuEqC5Jur1M//796d+/v6fDEEI0UH+fKOC9bZmUOl39t6d1CycmsGH23z6TardTmrwGRtlhjwb98atp9Ok8HH4BsD8FAF1Qa8wDviR9TnOco09gHDbCw1ELIUTV8kodfLMvh2U+bVBPJtz9ovwZ2zKYCD8ZTFeI6pKkWwghxDk5VZWFe3NYdMjVf7vjyfm3G3L/7dM5sjLIeeAfWAv/gOuAZTo0XY04szPBLwBU14i+9gN7sLz8T5ybs2Cqk5LjP+HX8h+eDV4IIc5QbHfy86E8fk7Jo9ShgqLQKcSHG1s3arADZQpxMSTpFkIIcVYFNgdztma4+/CNjA1ifCvpv13Gum0TOfeMw3HsCExQ0OnbYZr5Crkz7iZ9aEc018XQvflRsid3w7FmA5qQUEJe+oYC638oOfydJN1CiDrD5lRZdsTC9wdysdicADQP1BOTuYtbu8TLVLFCXCBJuoUQQlRJ+m+fXdF3n5P7z3uhtARtbCs0PQPQhsRijB9Jo66/kv3LDTgcO9ECtLNgHvcRvldfj+JjpGjFpzhLZPRyIYTnOVWV1ScK+WpfDhnFrum/ovz0jGsVTLcQPUuWbPBwhEJ4N0m6vdDx48fZvXs3gwYNwm6343Q6MRgMng5LCFHPlOu/7atjWlfpv11Gtdmw/OcJCj95BwCfwVcTPOtjcjdMwVF0lILtb5C/6Z+ojmLQ+pFimEiP6W9jMJx6/pxFqWiMMnq5EMJzVFVla1YxC/bmkJLvmv7L7KPl/1qYiW/imv7LZrN5OEohvJ8k3V7m66+/5pFHHkFRFA4dOsT27duZMWMGixcv9nRoQoh64sz+250aGbmvk/TfLuPITCfn/olY1yYBEHDfDAIffBpFo0Ef2puSjU9gS18FgCHyCgJ6/5d1f+5CUU5Np2PP2401fRXm/vM8cg5CCLEvr5QFe7LZkVMCgK9OYVSsmauiTRhl+i8hapQk3V7mP//5Dxs3bmTo0KEAdOnShZSUFA9HJYSoL6T/9tlZt64n+57xOE+kogQEYn71Q3yHXYvqtJOf/DL5m551FVR0mC57G//Wd2K324Fd7n2oTgeWDdPR+ITiGzvWMycihGiwjhfaWLgvm7VpRQDoFBgWbWJ0c7PcXBWilkjS7WW0Wi2NGjUqt0yalgshasLhfCuvb04jo9iOj0bhzo6h9I2U/ttlir7+lNyn7wdrKboWrQl+90v0rdpiy95C7qrbsGVvBEAX0h179masqUswRg4Gv+bufdjzdmPZMJ2So4sIGfw9itboqdMRQjQwOaV2vt2fy/LUfJwqKMCAxgH8X0szYb4yQJoQtUmSbi8TGBhIWloaiuKqdVq2bBkhISEejkoI4e3+OlHA+6f1336kawTRgXJDD0723/734xTOexcA49CRmF/7EMXPF8vmZynYOhNUO4rBTFDvN/FtcTOlRxaRu3oK6d+3QRd2OS0LFXKWvoI9YzUan1BCBn+PsdkoD5+ZEKIhKLI5WXQolyUpFqxOFYBuob6MjwuR93khLhFJur3Myy+/zNVXX82BAwfo378/Bw8e5Oeff/Z0WEIIL+Vwqizcl8NP7v7bvtzfOYwAvTQxBHBkppFz30Ss61x9tAMfepqAe2dgy95I7h+3Ys/dBoCx2RiC+vwXrV+U63H0tUQ0OULxoa8pSvkGnbofjbEl5v7z8I0dKzXcQohaZ3U4WXoknx8O5lJwcvqv1mYfJsSF0DZY3oOEuJQk6fYyPXv2ZPny5axevRpVVbn88ssxm82eDksIUQdZHU7WpBWyLq2Qw4bm7N+WRa8Ify6L8Meg1ZBvdTBnazrbsl2D6IyKDWJ8XDAaRfpvA1g3ryX73htP9t82ETzrY3ziryB/05MUbH8VVCcan1CC+ryDMeYGdwukMorWiF/Lf6CPHs+qxYtpOWCEzHErhKh1TlUl6VgBX+3PIavEAUATfz3j44LpEeZX4b1KCFH7JOn2QkFBQfTr1889XVh2drY0MRdClLMhvZD3t2eSb3PSOsiAj+rAYnXw7rZMPtudzXUtzCw5bHH3376rYyh9pP+2W+GXH5P37INgtaJr2YaQ/32FIyCDjEXdsFt2A+Db/EZMvd9EawzzcLRCCOGa/mtTZjEL92ZzpMA1zVeIj5axrYIZEBUgA2IK4UGSdHuZhQsXcv/995OTk4OiKKiqiqIoWK1WT4cmhKgjNqQXMmtzOt3D/JjYOoRQAyxevJ4R3TuSaYW3k9P5dHc2AOG+OqZJ/2031Wol71+PUPTFBwAYr7wW03/epHDvyxSufAtQ0fhGEdTnXXyjR3s2WCGEOGlPbgnz92SzO7cUAH+dhmubBzE82oRBK9N/CeFpknR7mbI5uXv27OnpUIQQdZDV4eT97Zl0D/Pj4a7haBQFm81V4+FwqvxxtICDFtdNOq0Cz/aKItgoHwUAjvTjZN97I7aNf4OiEPjws+jH9CTrj344Cg4C4NvqVoJ6vo7GJ9jD0QohBBwtsLJwbw4bMlzTf+k1CldFmxjVPEjG5hCiDvGaW1+fffYZd911Fz179sTHxwdFUUhISKhQzmaz8c033zB58mTatWtHQEAAgYGBXHbZZbz77rs4HI7zOm5sbCyKolT6M2jQoJo5ufMQGRkpCbcQokpr0grJtzmZ2DqkXN/sUrS8vjWTn1NcA6YNbhKAQ4XtJ/tzN3TWjX+TMfpybBv/RgkMIvi9z3B0P0T271fiKDiI1r8ZIUN/IbjfR5JwCyE8LqvEzvvbM5i+OpUNGUUouN7XZ/Vvyo2tQyThFqKO8ZrqjaeeeoqUlBRCQ0OJiooiJSWl0nL79+9n7NixBAQEMGTIEK699lry8vJYtGgRU6dOZfHixfz444/nNYhEUFAQDz30UIXlsbGxF3g2F+7OO+9k5syZjB07FqPx1MiT0dHRlzwWIUTdsz69iDZmH6L8Tw3YlZJvZalPHIU5peX6b6cW2liXXkj/xg27L3fh/LnkPf8w2Gzo4trh/+/7yDvwEM6jRwHwa3MPpu4voTGYPBypEKKhK7A5+PFgHr8etmA7Of1Xr3A/xrUKpkmAdBMSoq7ymqR77ty5xMXFERMTw0svvcSMGTMqLRcYGMg777zD5MmT8ff3dy9//fXXGTRoED/99BNff/01N9xwQ7WPbTabee655y72FGpEaWkpL774Iq+99hparesupqIopKenezgyIURdUGR3upuLq6rKH6n5fLorC5vGQJhRyyPdIt39t0N8dOTbzq/1T32ilpaS9/zDFC38CACfa0agXO9L3rbbAdAGtMB8+Vx8ogZ7MkwhhKDU4eTXwxZ+PJhHkd01/VfbYCM3xgUTZ5bpv4So67wm6R46dGi1yjVp0oSpU6dWWO7v78+0adOYOHEiK1asOK+kuy6ZOXMmycnJtGzZ0tOhCCHqID+dhpwSOyV2Jx/uzGTV8UIAGjss/LNnW4L9TtWEZJfaCTI0zCaIjrRjrv7bm9aAomB8fBxW8284U04ACv7tHiSw24to9P7n3JcQQtQWh1Plz2MFfL0/h5xS103SZgF6JsSF0DXUV6b/EsJLeE3SXRPK5kfV6c7vtEtLS0lISODYsWOYTCZ69erFZZddVhshnlPTpk0l4RZCVKlnuB/vbsvkib9SSS+2o1FgbPMg2L6VAH17d7ljhVb25JYytWPDm+6qdP1qcu6biDPjBESYMDzcnpKiT6EYdKY2mPt9hCH8ck+HKYRowFRVZX16EQv35XCs0DUYZqhRxw2tzPSLCig3ZocQou5rUEn3Rx+5mhAOGzbsvLY7ceIEt956a7llvXr1Yv78+edMgGfNmsWsWbOqfazS0tJyj+12u3vkYYD4+HgefvhhbrjhBnx8fNzLO3fuXO1jXKyyeE6P61Kw2+2X9HhCeCP7yT5+6cV2zAYND3SJoGWAlsXbT5Vxqirz9+QQqNfQO8LPQ5FeeqqqUvTFB+S9MA3sNjRDm6DG52ItWgGKloAOjxHY9VkUbd1qqnmp32tF3eSpz15x6e3KKeXLA3nsPznTRIBew7UxgVzRJAC9RsFht3MpOwbJtSc8yRuuv7KK3bNpMEn3+++/z5IlS7jiiisYMWJEtbe79dZbGTBgAB07diQgIIA9e/Ywa9Ys5s2bx5AhQ0hOTiYwMLDK7S0WC6mpqRcc919//UVeXp778YcffgjAF1984V6mKArvvffeBR/jQi1duvSSHm/Hjh2X9HhCeBOrw8knu7JYnlrgXhYT6FOh+fixQivz9+SwMaOIaV0jGsz8rWppCXnPPkjRV59AgIrm1nCcwQfBBrrgTpgv/whDaN2cGWLx4sWeDkHUIZf6s1dcOrmKka36SI5rXYM2alUnbewZtCnOwJHsZGmyZ+OTa094Ul2+/kaPHn3OMg0i6f7pp5+47777iImJ4bPPPjuvbZ999tlyj7t27cqnn34KwLx58/jggw+YNm1aldubTCaaNGlS7eOVlpaSmZnpfty3b1/69evnfnz05Gi6nmSz2Vi6dClXXnllte7s1JSgoKBLdiwhvMnxQhtvbU0nJd+KAlzf0kx0gIG5OzJ5ZNVR4oIMlOij2bgxnb15VgL1GqZ1jaBHeMOo5XYcP0r21AnYtq6DriqM0uFUjoKiI7DzUwR0moGirbuj/p7PjWJRf3nqs1fUvoxiO98etPBXWhEqoFUgPsqf0bEmzD6en51Grj3hSfXl+qv3SffixYsZO3YsERER/PHHH0RFRdXIfu+66y7mzZvHqlWrzpp0T5s27azrz5SUlMSAAQPcj3U6HXq9nsLCQvz9/bFYLJVuZzJd+qls9Hr9Jb34z7cvvhANwd8nCvlgewbFDhWTXsO9ncPp1MgXgC6hvqxNK2JtWgF5ipYIg5apHcPoHeHXYGq4S9euJOe+m3Da0mCSArFWwIa+UQ/Ml3+EPuTSdc25UN78JUPUvEv92Stqj8Xq4IcDuSw9YsHu6hlEnwh/bmgVXG7ax7pCrj3hSd5+/dXrLObnn3/m//7v/wgNDWX58uW0aNGixvYdGhoKQGFhYY3t82wGDBjAxo0bMZvNKIqCqqrudYqi4HA03Gl/hGiI7E6Vz/dk8+th1424NmYf7u8cTojx1Nu6Qauhf+MALgvzYfHhNYzo2M6rP7DOh6qqFM37H3n/fhQ6W2G4E/RO0PgQ2PV5Ajo8gqKp1x+BQog6qsTuZMnhPH46mEexw/V9rkOIkRvjQmgR5HOOrYUQ3qjefuMoS7hDQkJYvnw5rVq1qtH9r1mzBoDY2Nga3W9VHn30UQCcTuclOZ4Qou7KKLbx1pYM9ltcAy+Oig1iXKtgtBoZzRZALSkm9+n7Kf5jHtxog+auL7X6sL6Y+32EPqithyMUQjREdqfK8tR8vtufS67VVVkSG2hgQlwwnRrJ9F9C1Gf1MulesmQJ//d//0dwcDDLly8nLi7urOVtNhv79+9Hr9eXG418165dREdH4+dXvt/jrl27mD59OgATJ06s+ROoxGuvvXbJjiWEqLs2ZhTxbnIGhXYn/joN93QKo3tYw+ibXR32Y4fJvmc8dr91cLcDDIDWF1P3/+Df9j4UTcOcl1wI4TlOVWVtWiEL9+WQVuSaiSXcV8e4VsH0ifSX6b+EaAC8JumeO3cuSUlJACQnJ7uXJSYmAtC/f39uv/12du3axXXXXUdpaSmDBg1i/vz5FfYVGxvLLbfc4n6cmppKu3btiImJ4dChQ+7lCxYsYNasWQwcOJCYmBj8/f3Zs2cPixcvxmazMWPGDAYOHFhr53y605uTCyEaHodT5ct9OSw65JrNoIXJwINdwgnzbRjNxauj9O8VZD89DjU+A5q53jMNkYMw952LznT26R2FEKI2bMsqZv7ebA6enP7LZNBwfYtgrmgaiE5aJwnRYHhN0p2UlMQnn3xSbtmqVatYtWqV+/Htt9/OiRMn3HNdL1iwoNJ9xcfHl0u6qzJ48GB27tzJpk2bWLlyJUVFRYSGhjJixAimTp163vN9X4zU1NSzDsh2PnOBCyG8S3aJnbe3prMr1/XeNjzaxE2tQ+QL20mqqlKQ8Bb5iY/BBBvoQNH6Y+r1Gn6t70RRGsagcUKIuuOgpZQFe7NJzioBwKhVGBkbxNUxQfjq5D1JiIbGa5LuhIQEEhISzllu0KBB510rHBsbW+k28fHxxMfHn9e+aotWq5Ups4RogJKzinlnazoWmxNfrcKdHcK4LNLf02HVGc7iInJenEhpwI9whet93CdyKEH9PkQX4PmpdoQQDUtakY0v9+Xw1wnXQLtaBYY2MzGmuZkgH+neIkRD5TVJd0MXFRVVYc5wIUT95VRVvt2fy3cHclGBmEADD3QOr5PTyNQWZ1EulkUzKE5dRDebhcz9JnybjMI06j9o/MzYjuwl6+3BONukghZQfQnq9w5+rW6RAYmEEJdUXqmDbw/k8MfRfE4OSE6/KH/Gtgwmwq/hvG8LISonSbeXkD7dQjQceaUO3klOZ1u2q1ni4CaBTG4b0mDm1gawLHqagtSZ4OsEJQiHw4jOUEBRyf8o+vR9DMpVWAt+g/auQYn0Af0IufpLtH6NPRy5EKIhKbY7+flQHj+n5FF6Mtvu0siX8XHBxJpk+i8hhIsk3V7ihRde8HQIQohLYFdOCXO2ppNT6sBHo3Bb+0YMaBzo6bAuKcuipynIfBFNUWPMAz5G23owixcvZsSIEdh3/UJO4g1YAxeDESjVYer5Bv7d7pXabSHEJWNzqiw7YuH7A7lYbK7pXFuYDNzYOoQOIb4ejk4IUddI0u0lRo0a5ekQhBC1yKmq/Hwoj4X7cnCq0MRfz4NdwmkaYPB0aJeUsyiXgtSZaIoaE37/QTR6AzabDQDr0UQsq/8BJteActghdNRGDFGdPBixEKIhcaoqq08U8tW+HDKKXS1tovz0jGsVTO8IP7n5J4SolCTdQgjhYQU2B+8mZ7Apsxhw9QOc0i4UYwMc4dayaAb4OjEP+BiN3nXDwWnLJzb7bfJW/O6q3S5QMHAV1oAlFK18F8O4/3o2aCFEvaeqKluzilmwN4eUfNf0X2YfLf/X0kx8Y5n+SwhxdpJ0CyGEB+3LK+WtLelkltjRaxQmtQ3hiiaBDba2pOTYTygEYewwDFveLgq3vE7Rwc8I07j6t7PTj+AxX+HbZwTH3wiihEWAJN1CiNqzL6+UBXuy2ZHjeh/y1SmMijVzVbSpQd4cFUKcP0m6vcThw4fPuj46WqbGEcKbqKrKb0csfLY7G4cKEb46HuwS3uAH3lEpAr2e9PldsFu3nlqRpaDZ05awZ39DG9UUAAUzqlrgoUiFEPXd8UIbC/dlszatCACdAsOjTVzb3EygQab/EkJUnyTdXqJHjx7umq+srCz0etf0EzabjUaNGpGenu7J8IQQ56HI7uSD7ZmsSXPN49o73I87O4Thp2+4NSb2ojQK/nwW1ZQDOhW7NROcwF4NmhMtOWSOp/trs9AGnBpUTiUXRTF5LmghRL2UU2rn2/25LE/Nx6mCAgxoHMDYlsGE+spXZyHE+ZN3Di+RkZEBwPTp02nVqhVTpkwB4KOPPmL//v2eDE0IcR5S8kuZvSWdtCI7WgUmtg7hqmhTg2xOrqoqJTu+I/+vF7BrtoJWPfWptM0f37CbCZg0FVq2Zc3ixSg+Rve2Jdt+QQ2x4Ot7k2eCF0LUO0U2J4sO5bIkxYLV6Zr+q1uoL+PjQogObFiDWgohatZFJ92FhYWsWrWKv/76i2PHjpGRkUFJSQmNGjUiLCyMdu3aER8fT+vWrWsi3gbv119/5eWXX3Y/vv322+nWrRv/+c9/PBiVEOJcVFUlMbWAhF1Z2JwqoUYt93cOJ85sPPfG9Ywj5ziWxU9SkvUNalA+6E+uOKZFZ+uFPXwNmigTQfe/WW708jJOm5Xc36aAnwbTDTMv/QkIIeoVq8PJ0iP5/HAwl4KT03+1NvswIS6EtsEN7z1aCFHzLijpttlsfP3117z//vusWrUKh8PhXqeqrjuDZ9baREREMHHiRO68805JwC+C1Wpl9+7dtGnTBoA9e/ZQWlrq4aiEEGdTYnfy0c4sko67+h93DfXlno5hDapPoGqzUbT8Uwo2vYYjaDf4qhAE2EGT3gS/VncScP/DaAICsfz0DAUZ/yJ9TnPMw13zdJcp2fYLub9NwRl8jICwp9H4mT12TkII7+ZUVVYeK+Dr/Tlklbi+yzbx1zM+LpgeYTL9lxCi5pxX0l1SUsJrr73GW2+9RVZWljvB1ul0tGnThtDQUEJCQvD19SU7O5vs7GwOHjxIRkYGJ06c4I033uCNN97giiuuYObMmfTq1atWTqo+e+mll+jXrx9dunQBYOvWrXz00UcejkoIUZXUAiuzt6STWmhDo8C4VsGMjA1C0wC+zKmqinXbBgp+mUlp0RKILYHIkysLDBh8hhJ05X/Qx3Qut51p5AuwSKWgdCbZ64fDbyY6F/uQcaAUQizgpyEg7GlXOSGEOE+qqrIps5gFe7I5WuhqSRPio2Vsq2AGRAWglem/hBA1rNpJ98cff8wzzzzDsWPHUFWVDh06MHHiRAYOHEiPHj0wGqtufnPo0CHWrFnDDz/8wI8//siyZcvo06cP48aN45VXXqFZs2Y1cjINwbXXXsvOnTv5+++/Aejbty+hoaEejkoIUZmk4wV8uCOTUoeK2UfL/Z3CaBfi6+mwap3j+FEKf/yQop3v44w9BuGn1mmLY/Hv+BB+fe9Fo636I8g06l8EFD2C5acnKVZ/RKu1oKgmfH1vwnTDTKnhFkJckD25Jczfk83uXFcrQX+dhmubBzE82oRB23AHsxRC1K5qJ91TpkzBYDBw5513cvfdd7trWqsjNjaW2NhYxo8fT2FhId988w2vvPIKCxcupF27djzzzDMXFHxDFRYWxqhRozwdhhCiClaHk093Z/PH0XwAOoQYua9TOEE+9bc5ubMgn5Jfv6dg2bvYfdZCBwd0O7nSbsAYfA2Bg/6NPqRdtfep8TNjHvdf/G1vsnjxYkaMGOGeuUEIIc7H0QIrC/fmsCHDNf2XXqNwVbSJUc2DCNDX3/dmIUTdUO2k+6677uLJJ5+86Fppf39/Jk2axM0338xXX31VYYAccXZ79+7lgQceYMuWLZSUlLiXZ2dnezAqIUSZtCIbs7ekk5JvRQGua2Hm+pbmetmcXHU4KF39B0Xff0rJkW+hSzFcprrXa5RoAro+il/7KWh0fh6MVAjRUGWV2Plmfw4rUgtQcU3/NahJANe3DKaRUSbxEUJcGtV+t3n33Xdr9MCKojBu3Lga3WdDcMcdd3DPPffwwgsvsGDBAubMmUNsbKynwxJCAGvTCnlvewbFdpVAvYZ7O4XRObT+JZu2XckUffcFRX98hhp7HLo5oKxbtqrFJ3Ikgd0fRx/WVwYiEkJ4RIHNwY8H8/j1sAXbyem/eoX7Ma5VME0CZPovIcSlJbf4vIzFYmH8+PG8+OKLdOrUiffee4/LLruMJ5980tOh1VlqaQnFi7+h6NcfaHPoAHlLPsdv+Gh8R/xfuXl/6ypvj78hsDtVvtiTzS+HLYBrqpkHOocTUo9qURwZJyj+cSGF332Go3QL9HLARCec7AKp0Yfj1+F+/FvfgdY3wrPBCiEarFKHk18PW/jxYB5Fdtf0X22DjdwYF9wgp2gUQtQN9ecbYQNR1p8xMDCQQ4cOERkZSWZmpoejqrtKfv+J3Bl348zORNejLzb/QJzZGeQ+OgXLzOmYX3oP45BrPB1mlbw9/oYgs9jOW1vT2ZfnGpRnVGwQN7QKRlcPRr91FhdRsvRHir/7gtJ1S6GTDQY7IfRUE3JDxCD8292Psdm1KBr5SBFCeIbDqfLnyem/ckpd0381C9AzIS6ErqG+0upGCOFRF/UNyWq1cuLECQwGA5GRkeXWFRQU8Nxzz7F06VI0Gg0jR47kySefxNe3/o/cW5sGDhxIVlYW9913Hz169MBgMDBhwgRPh1Unlfz+E9n3jMN4xTWYnpiJ2jSWvxYvpu2IEShHD2F56Umy776BkHe/xDh0pKfDrcDb468vSouLSfp9JeszS8hzKOz6bAk9Q430HzqAHQUq727LoMDmxE+n4Z6OofQI9/d0yG4X0kpCdTqxrvmTou8+p+SX71D9La5a7QedcLJFpqILwK/VLfi1mYreXP2B0YQQoqapqsr69CIW7svh2Mnpv0KNOm5oZaZfVEC9HE9DCOF9Lirpnjt3Lvfffz+TJ0+uMFf0NddcQ1JSknsu761bt7Jy5UqWL18udxsvwquvvgrAxIkTGTBgAHl5eXTs2NHDUdU9amkJuTPuxnjFNQT/dwGKVltu0D5d8ziC/7uAnKkTyJ1xNxED9tWpptreHn998dfSFXxUYKLQP44W2j34FueQHxDMhz5xfLrsEDaD6zlvYTLwYJdwwnzrzsja59tKwrZvF8Xff07x9/NxpB2Bdk64wQHRp2q1deYO+Le5F9+W/0CjD/TEaQkhhNvO7GLm781xtzQK0Gu4roWZoc1M6OtBayMhRP1xUUn3r7/+CrgSwNP9+OOPrFy5Eo1Gw8SJE/H19eXTTz9l5cqVzJs3j0mTJl3MYRu8b775ht27d/Pkk0+i0WhITk6mU6dOng6rTile/A3O7ExMT8xE0VY+FYii1WKa/m/Sr+xM8ZJv8RszsdJyF0J1OsFmQ3XYwWEHu931d9lv26nHOOyo7t82sNsp+fM3nNmZ+MQPo3jpt1iLVmIt/pv2hZnkLpmDX6vx+LW5udbiF66E+21HEzrl7eSm9gFEDr6CxYsXc/mQeN7ccIwDuBLuzlh4pHfnOvUFr6yVhM+QqzDc0pfSotXoj+9HE9WSQL9/YU34i+y7byDolQ9Q83Ip/v4LbMkbIFCF7g6YqIK/qy8kihZj9PX4t70XQ8RAuWkqhPC4w/lWFuzNZnNmMQA+GoWrY4MYGROEn17m2hZC1D0XlXTv3LkTgB49epRb/sUXX6AoCtOnT+ff//43AN27d2fq1Kl88cUXknRfhGeeeYZ169axf/9+d9J91113sXr1ak+HVqeULF2Eoefl6JrHoTpKKNz8HgVr5tClNJes/wWitcSgzWmGYgMluBGWl/9J8U9fnUqK3Qmyo1zyXJYcV7bu9MQaVT13kNWQN28qjLKDP3BYwd+iYEs7RF7OMvJW3IVmQwuUoGDyZ7+A49gRtFFN0TZu5vod0QTFx6dG4rgY3jgQXGlxMR8VmOiUt5PH/nE1Wp0Om81Gmsafp9elYbEp+GggIvMI+30CcZaWQB3pOlPWSkL/f92wdV1J6e7v0IX1w6YE4SzJIP/I4yiXB6Jk+5P36BRAhRgVbnBCWycormtX4xuJX+s78Y+7E61/E8+elBBCABnFNr7al8uq467pv7QKDG4SyHUtzQT7yJgSQoi666LeoTIyMvDz8yM4OLjc8uXLlwNw++23u5fdfPPNTJ06lS1btlzMIRu8H374gY0bN9KzZ08AoqKiKCgo8HBUdY/Tkosmogklh38kd/UUnKWZkKVgsCg4Tdk4ow9hCwYW6SBHiwqUph+v/cD0ehStDnQ60OpQdHrQ6Vy18e5lOhypR1BbO2BULkpaI3QbW0NxIHkpB/EvtKDqsmGoA2e//ZCqw7Enh/zXn61wOE1oxKkkvOzntMeasMgqWwLUBG8dCC7p95UU+sdxU/sAtDodTlXlh0MWEg0twOYkOsDVnNx+xMb0w3qSfl/JkFHDLll8qtMJDgc4Ha6bP6f9XfzTVzhD03C2O44hcAgBXR5H1TZm26LvabL1MPa/d6L2zYWr8yFCAy11EHyq64IhfAD+be/FGH0dilam1RFCeJ7F6uCHA7ksPWLBfvKedp8If25oFUyUf93p1iOEEFW5qKS7sLCwwsBohw4dIiMjg+joaJo3b+5e7u/vj9lsJjs7+2IO2eD5+vqiPSNJUmuoVrU+0ZjM2NUtZCd+gbHpKPxbPE7xV0vYe+wgcdHtUUrzKPVdjH38djTLItDkNiFg0j1wMiFWyv3Wg057xrKTCXO5ZdrTkujTEmutzpVsa6rf5C3r3hso7fIDxujRBE/6BkXj6tO9evFiRowYgba0BPuxFPK23IltzFo038bh06UPjuNHcRw7guP4USgtwZmZhjMzDdvW9ZUfSKdDG9H4tKS8WfkkvXEzFHPIBTUp9paB4NTSUpz5eagF+Sd/W1iXmktz/XaCjx9my8qlfBHWgSO+0aAoXJb7E2PXfo/P11H42BViO45lbVEu3e4aWyEBxul6rDqcp/52nirjWnfa32XJdGXlyh47HGc/Ia0KD9lhlwbrVyvIVv8EoC1QAhDqBIc/KAXQ0wlYUXR++La4Gf82U9GHdD7LzoUQ4tIpsTtZcjiPnw7mUexwfdfpEGLkxrgQWgR5viWXEEJU10Ul3SEhIWRkZJCbm4vZbAbgjz/+AODyyy+vUN5utxMQEHAxh2zwYmJiWLlyJYqiYLPZmDlzJl27dvV0WHWOz9DhlJxYiCFkCMGDXEmr5qFeHFu8mK4jRqDX61GdM8laPBxr32UERr2I33W3eDpsN+3AUCix4RcxFUVTsSZaExCIoXVHAq3PkL3haoxTBmAe91/3elVVceZk4Tx+FPuxIziPHz2ZkB92/T5+FEfaMbDbcaQexpF6uMpYFKMvmkpqyU9P0DX+5V/Xpw8EZ56TQMmRbyla+ThtCvaTtzIBv5jrMc9JIPf+Wy54IDjV4UAtzC+fMOefSpyd+RbUAgtqvgVnlb/zwGqtsO+iBz/CP+8YH+osrO14A6qiwWi3MGbXC/Qs/A6iVUpCgEU6giL7UhhgpuT3n84r/lrT3unqjrDCF4w68NeAr4ItzIHPID+cAceBUzXbyrEoIh7ZgcZg9lTEQghRjt2psjw1n2/355Jndd1ojA00MCEumE6NZPovIYT3uaiku3v37vz66698+OGHPPLIIzidTj788EMURWHw4MHlymZkZFBQUEC7djK9zMV46623mDx5MsnJyfj7+zN48GA+//xzT4d1Vv/5z3/cg7/5+fkRHx/PK6+8QmxsbO0dtL0K+cBSHVxdRRn15PruQDsHqqME1WkHpw3VaQPV7vrttKGqpy132lFV13KcVZSpxrZnHuv0v0uVFVCskPvbZHSpnVz7c9iIKyjCsmo+WmMoGoOZkh8XQbAWW6ONlKYlofEJcf0YgtGGhKINCUXfoWvlp+9w4Ew/fioJP1lDfvpjZ1Y6akkxjoN7cRzcW+XTrZjM5ZJyZ04WzuxMtEOjSfs6GtWWXa5fcW7SJBT9Q/iNfgDn74uwzP4Xhi49UfPzcBbkV+u3Wliz3SoU/wCUwCAIDKI4MIQDrXvhPDnvdJ+sLYxJ382Jg4H4t/sPWHMp9fsZ+/htWHRNCLQUE/Tvd1xN9TVaOPlb0Z7x98l1ilZTzXJa0GhQNRpQS1AdFpzOPJx2C6o9F6ctD9Weg9OWi2rNwWnNpvTwMnBoUO43oFpzT17ooAec5IGiwdh0FH5t7yVn4VgUo1YSbiFEneBUVdamFbJwXw5pRXYAwn11jGsVTJ9If5n+SwjhtS4q6Z48eTK//PILTzzxBL///jsZGRls3LiRwMBAbrjhhnJlV65cCSBJ90WKiIjgl19+oaioCFVV8ff3Z9OmTYSGhno6tCqtWLGC+++/n169elFaWspjjz3G1VdfTXJyMjpd7Qx8Unr8Z3SG9lgX/0lOyQT87r+V3J1306W4gMxvtGAvRbUWQWfXHfS8NbeTt+b2c+z1EvMFp+8JrMdPuBeZgdKUjafKnOzBYctaQ9YvA8ptruj8UAwhaHyC0RhOJePKaYm5xicETWQI2pjm6A090PiEoOhN7loEtbQEx4nUShPysr/V/DxUSy52Sy723dtOBdDaQWHBLNijgd/1ODhEUEkJ9tJiCNKjDs2lsPVz0FpH4fuvU3ihz5PBB02ACSXQVPF3YBBKQOAZv8vWnVbWPxBFq2V/Xikf78wk1eKq/Q53Hufu3l1pGzIGm83GpsWL6eZuKfEiOxZP4qChM1NMO/G/dkK1wlUdpThLs3CWZp/8nXHqcUkWarl1J3+s2a6bPNVx8iWlWnPcixS9iWKHP8Ftbyaw3VR0ATHYD+xBPV6AtnOz83q6hRCiNmzLKmb+3mwOnnz/NRk0XN8imCuaBqKrQ7NDCCHEhbiojGf8+PH8+uuvJCQkuKcPMxqN/O9//3M3Ny+zcOHCSmvARfWtX7+elJQUBg0aRKNGjdi+fTv//Oc/WbVqFRkZGZ4Or0q//PJLuccffPABLVq0YMeOHXTuXDv9R53WXHSNO2F692VyZ9xNyR0/wN02DIBaerLQucYPU7Sg0aNo9KDoXL81ehRFd2q5RoeinPx9cn1Z2bLtKt2HRgfKafs4Y99F+xJQ7YUYtSMo+moeqiUfTWxrLBoHJoMNZ1YKmI0YLuuBzbEVUND4hOC05qCW5gAqqr0I1V6Es+jo+T15iuZUcl6WmBtCUBoHo2kegs6nFQZDL1eC7hOCYtOj5hTjzMzHeSINx7EjFH7zMeroo3A0EH4ASq2oZJ56w8nWwDdamKDCtVZ4LxBD6y4ogUFoAgJRTibHmkDTqd+nrSuXXNfACO35VgcLd2ey/Gg+KmDEjtNZSnh6OnGmygcTc9jt/Jjzf/iHZtE16m9KjqquBLnkVKJ8euKsnkykVfsF314AjQ8an0YnWzQ0OuPHtaxw93vYdm/EcOQKzC9+jNYvDLsDFi9ezIiuI9Dp9agOB5aX/wmxOnRRrS48HiGEuEgHLaUs2JtNclYJAEatwsjYIK6OCcJXJ9N/CSHqh4uuZvzoo4+YMmUKq1evxmw2M2TIEFq0aFGujNVqJSgoiEmTJjFixIiLPWSD9PLLL/Of//yHtm3bMmPGDO6//36mT5/O1KlTSUhIqFD+s88+Y+XKlWzYsIHk5GSsVisff/wxt9xyS5XHWLduHc8++yyrV6/GZrPRqVMnpk2bxrhx42r0XPLy8gDXmAC1RWMw4yxKxXj1SCIG7KNo8QIKkz4jN/UYwVHRGPtfiXHQNWiMAWQnXo/GGEHwgM9PJcCKzqN9xjQ+jchNmoT/mHsxXfUyxUu+peiX73EeOoAutgV+o/6F79XX4yhJIf37tpj7z8Ov5T8AUFUnqjUPpzXnZI1ptqvpcWn2qWXWbNTSnJOJYfbJZD0b1VEMqhNnaRaUZnGOIbsqUHR+KM1CUCdngY8Tw2WXob0iGsVpxFkMBw+n0qJtG7RGI+j1qCUZFO56C81kPwyD40F1AurJKdecqGoeKrk4Tl9e7IQiFdJVd3n1ZHnXdqeWu9ZVvhzVidMJq5w9+NE+nCL8AeitrOOa3OdJcbbg44g3ePn7zxljXEKYIYd2+YfI/vFRTtj8+Ml3KjvCh3BLzl2Upv9B6Y7zeaLKbmw0qjyJNoSgMZ567Gqx0Mj1/J7rutToyc2ahPXLFVgeeRDTEzOhaax7tf3AHiwv/5OSzYvgcivG2LHnEbgQQtSMtCIbX+7L4a8TrhuRWgWGNjMxprmZIJ/am1VDCCE8oUba9vbr149+/fpVud5gMPD+++/XxKEarISEBHbs2EHjxo3ZtWsXHTt25Ndff2XIkCGVln/qqadISUkhNDSUqKgoUlJSzrr/5cuXM3z4cIxGIxMmTCAwMJBvvvmG8ePHc+TIER555JEaOQ+Hw8Gjjz7KiBEjaNq0aY3sszLG6DHkJk3CnrcHXVBr/K+7BcPIm/jr5Ojfer1rihF73m5smesw95+HxmCqtXjOl2/sDVjWTcOy4XGCB32D35iJ6K+5gVWLF9PS3bzZgWXVdDQ+ofieljgpigbFJxiNTzAEtjjLUSpSHSU4SytLzE8l6OppybzzZD/iM2vXOVn5bD3+e7n9R+mheH/F4zpDUinY8vz5Pk0X5bC+M9+ZnueIoYsrNtsurst7lha2dQC0Zwe35BTzZdBLvKgdSKx1PUGBJ8jTRnIosCf+jixuybmLDtY/QWNEb25/KkmuUBNd/rFiCEJRaqcGp+za0U5rSenrq0kf2gld9z60dCrkfPYG9o1/o/w/e/cdHlWdtnH8Oy29TUgg9FACCCIoRZCuCIgFFRFwLbBrWVHXXVwXu1jWti7oK6ursgs2Ogq6ojQBARFFQcACofeS3jPtvH9MMhAIkJBJJuX+XFeuZM45c85zwo/J3HPKU68etocuxm3sKDF2REQqW2ahm493pfPVgWzcBpiAyxqGc1MrOw3C1P5LRGqnyrmgVvwuJCSERo0aAdCuXTvatGlzxsANMHXqVJKSkmjevDkvvfQSjz766BmXdblc3HXXXZjNZr7++mvf3dCfeuopunfvzmOPPcZNN91E8+bNfc95//33uf76689a86mtzAzD4I9//CP79u1j7dq159jjijk1tJZ2B3DD4ybrh9NDa3VgsoQQ0+u/pK24nvSVw4nq8gqEnWjB58rcRtYPEyg48BmxAxZgspTvzt9n264lrCGWsIblep5heDCcWb4gnrHm97h+/RVr3oWEDr8RjyMDd0Eq+w/so2mTZpgtFgwDHGu+wh26D3NCA0KaDQPMRUdyTWAyF303Aeai76aisHr6dEwmTCUen76cCRM5nhAWZHVgdV4iBiZCTE6GRW9nQOQ+LKYxwFhyk9/BcOZw2YUj6eb8gfXbC9iY34Asd2OicDM2aj29+lxKaPQXpC65HHNIA2IHzPfLv0FFnTx2gl8YSlBmfwqXrse6ZxfmxJZEvvI8juhVFB5a5NexIyJyNvkuD5/vyeTzvZkUFrX/6lQvlJFJdhKj1P5LRGo3he4aoqCggC1btviCrGEYJR6fem30wIEDy7zur776ip07dzJ27NgS7ceio6N57LHHGDNmDO+99x5PPfWUb96wYcOYOHGi74jxuRiGwbhx41i2bBlff/018fHxZ1w2N7f0a17z8/PLtkMELrT6U0jTa4nt/wkZ3/yBYwvaYo2/jFa5JtKXvoLr+DeYg+OIHbCAkKbXBrpU79H1oBjfXbCtUa2huQvXU7/hPPqTr0/3nkWLaN9jKKb9u8l6+XHcXx3B+mxbrPHtiOnx5tk3UkEew2DVwRxmJqeR4/QA0LthBLe0sRMT3Kbk/tgiyFhzO8EN+hEe3YbBHeByp9N7XfTQa0ucKeE4tpaY3h9Uau3ldfLYKSz8H9brLsOVEYIn5iDZxx/G7Kw+Y0dEajenx2D5/iwW7Mogq+i1t2VUEKPbxNIhNjTA1YmIVI0yh+6rr76aZ599li5duvhlw/n5+fzrX/8iPDyce++91y/rrM3y8/O57rrrSkwrfmwymdi1a9d5r3vlypUADBo06LR5gwcPBrx3ID9ZdHQ07dq1K1PoNgyD++67j88//5xVq1bRtOnZ75Zc1l7uLpcLp/PMd3S2JAwhqs9cstffw7EFbbHU60mrXDNpi1/GnboOU3AcUX3mYUkYctb1BJKl4VXEXr+Lwn3zKdi3AKuxC1NQSyJ7TiO42XBMlpBqWbut8TUU7PuY8NemkPf0Cxwb2BHLxZfSyjCT9sEk3BvXY7LXI/y1V8lNuY/Qxg9X6n7sznbw/rZ0dmV7t9Ek3Mptbey0iwkGjNO2bW18PabgODI2/JWo3nMwmS2+ZYq/Gx43WRsexhQch7XxsGr371BTx05pTv3d1zQVrb+sH26KVCcew+CbI7nM3ZHO8Xxv+6+GYTZubm2ne4My3J9CRKQWKXPo/uKLL/jyyy+55ppruPfeexk0aBBmc/mvSdy7dy8ffPABU6ZM4fjx40ycOLHc66iL9uzZU2nrTk729l9OSko6bV5CQgIRERG+Zc7Hfffdx8yZM/nss88IDQ3lyBFvC6zY2FiCgkq/M3RZrFu3zndTtjOzYAp5k1jLN8RkfYvVyOJ4VjgZYX8mzXYZxmYzbF503jVUHTswFiKAXOBX4NevAlvSWZiMCDqZojiQ8T47J0widvP3xGz5DmtBNsdDwsi45X7SLupGq4xJRJiiWPFLOMav/v93KMTCFlsCOy2xYDJhNdxc6DxKUn4Ku1LgbB9VRVvvJunASyTP68f+0DsotDQGYOnSpYS4D9Ik/z1iXBtIDn+EzMXV99+ipo2ds1m6dGmgS6iQ861/2LBhfq5EpPIYhsHm1HxmJaezN9vb/ism2MLwVjH0a6T2XyJSN5U5dC9dupSHHnqIzz77jP/973/Ex8czYsQI+vTpQ/fu3UlMTCz1eXl5eWzYsIH169fz6aef8s033wDem6s99NBD/OlPf/LLjsj5Kw6u0dHRpc6PiooqQ7g9s7feeguAPn1K9pFesWIF/fv3P235nJycUtfzzTfflDga37Nnz7PewK8kb5/lpUuXcuWVV9bII0c1rf7CA1Zsq2/istiPCP/zixihz/rqN+XvInfTYzgObiCqzzyuanKNX7ftMQxWH87j812ZvlPJezYIY1SraGKCm5/j2cWGUnigC+b192DPvg9LvZ4czzITH+XBneE9UyLysnn08nPtlaGmjZ1TqX6RmmFHZiGztqfxS7q3/Veo1cS1iTEMaRZFiNp/iUgdVubQfcUVV7Bx40amT5/OK6+8wrZt23jzzTd5803vdZiRkZHExcURGxtLcHAw6enppKWlcfz4cTwe75tewzAICQlh9OjRPPXUUyVuzCW116k3VDuX8PDwUqeHhpa89stqtZ7XG1ibzVaj3/jWlPptLW7AavFeV5z+vwt916TnrKzca9J3ZxUy7ddUdmR6G7I3Cbcx9oJ6XHAe1w7aWtxIeLOh5O+ZR97e+Vgzd2IJa0XkBR8QmnhTtbwXwNnUlLFzJqpfpHo6nOtk9o40vjuaB4DVBIObRXFdixgig9T+S0SkXDdSM5lMjB07lrFjx7Jq1SreeecdlixZQmpqKllZWWRlZZV6bbHFYqFLly6MHj2aO+64g5iYGH/VL35QfIT7TEezs7KysNvtVVmS1BIhza6jQeP9J0KrsRNzSCtievs/tOY43cxJTmf5gWwMIMRi4qbWdgY1jarQ6YwmSwhhrW7F1mykt2Vbn6EKTiIiQHqBi/m7Mlh5MBtPUfuvPo0iuKmVnbhQ3atXRKTYeb8i9uvXj379+gHwyy+/sH79eg4dOsTx48cpKCigXr16xMfH0759ey677LIy3xxLql7xtdzJycmn3SjvyJEj5OTk0L1790CUJrVAZYdWj2Hw9aEcZm5PI7voVPLLEsL5XZtY7CF60yci4m95Tg+f7cngi71ZODzes9kujgtlZFIszSLP/14tIiK1lV/ekbZv35727dv7Y1USAP369ePFF19kyZIljBo1qsS8xYsX+5YRqW5OPZW8cdGp5O3VhkZExO8cbg9L92ezcHeG734ZbWKCGZUUSzt7zbrcRkSkKukwkHDFFVfQsmVLZsyYwZ/+9Cdfr+7MzExeeOEFgoKCuP322wNbpMhJcpxu5u5IZ9n+E6eSD29lZ3Czip1KLiIip/MYBqsP5TBvZzqpBW7A+yHnyCQ7XeLV/ktE5FwUumupqVOnsmbNGgC2bNnim1bck7t3797ceeedgPeGZFOnTmXw4MH07duXUaNGERkZyfz589m7dy+vvvrqGe9OL1KVit/4zdyeRlbxXcmLTiWP1ankIiJ+ZRgGG1PymbU9jQO53j7zscEWbmptp0/DCCz6kFNEpEz0LrWWWrNmDe+9916JaWvXrmXt2rW+x8WhG2DAgAGsWbOGp59+mtmzZ+N0OunYsSMvv/wyI0eOrLK6Rc5kT1Yh039LZXvGiVPJx1xQjw46lVxExO+2ZxQwc3sa24pec8OtZq5rEc3gZlEEWdT+S0SkPBS6a6np06czffr0cj2ne/fufPHFF5VTkMh5ynW6mbsjg6X7szCA4KJTyYfoVHIREb87kONgdnI6Pxz3tv+ymU0MaRbFtS2iibCp/ZeIyPlQ6BaRasljGKw5lMOM5DSyHN5TyXsUnUpeT6eSi4j4VWqBi/k701l1MAcDb/uv/o0jGN7Krst3REQqSK+iIlLt7M323pW8+FTyRuE2xrSrx4X1dCq5iIg/5TjdfLo7k8X7snAWtf/qVj+Mm1vbaRyh9l8iIv6g0C0i1Uau0828nRks2XfiVPIbW8ZwVfNonUouIuJHhW4Pi/dl8enuTPJc3rOJ2tlDGJ1kJylG7b9ERPxJoVtEAs4wDFYfzmHG9hOnkl/aIJxb2+pUchERf3J7DFYdymb+zgzSC73tv5pG2BiVFEvnuFC1/xIRqQR6Nysilcrh9rD+aC7fH81lX1ALdm5NpVuDcC5tEE6Qxcy+bAfTfk3x3SG3YZj3ruQddSq5iIjfGIbBhmN5zEpO53Cet/1XXIiVEa1j6NUwArPCtohIpVHoFpFK88OxXN75OYVsp4c20UEEG26yHG7e2prCB9vSaBMdzKbUfDwGBJtN3NAqhqE6lVxExK9+TctnZnI6OzK9H25G2Mzc0DKGgU2jsOn1VkSk0lUodGdkZLB582YiIyO5+OKLS8w7fPgwDzzwAEuXLsVsNnPNNdfwz3/+k/r161eoYBGpGX44lsukTce4JD6MW9rEEhcEixZt4KqLO7D4YB5zd6TzY0o+AN0bhHFrm3rEhepzQBERf9mX7WBWchqbil5rg80mrkqM5prm0YTZ1GtbRKSqVOgV9z//+Q8DBgzgv//9b4npLpeLQYMG8cknn5CdnU1mZiYzZszgiiuuwOFwnNe2PvzwQ+655x66du1KcHAwJpPprH2os7KyGD9+PM2bNyc4OJjExEQefvhhcnJyyr3txYsX069fPyIjI4mKimLAgAEsX778vPZDpC5wuD2883MKl8SH8ZfO9WkYbgMgwxTCCxuPMzM5HZfhvVFaqNXEuAvjFbhFRPzkeL6TN7cc59F1B9mUko/FBAObRDKpTxNubm1X4BYRqWIVepe7ZMkSAEaPHl1i+uzZs/n5558JDQ1l/PjxhIaG8o9//INffvmFd955h/vvv7/c23riiSfYu3cvcXFxNGzYkL17955x2dzcXPr168emTZsYNGgQo0ePZuPGjbz66qusWrWKr7/+mpCQst2Z88MPP+S2224jPj6eMWPG+PbvyiuvZM6cOdx0003l3heR2m790VyynR5uaROL24DtGQWsO5TNsuAkjEwHQWYTN7SM4eL4MB5Zd5DvjubRu1FEoMsWEanRshxuFu7KYOn+LFze7l/0aBDOiNZ234efIiJS9SoUunfs2AFAx44dS0yfM2cOJpOJZ555hr/+9a8AtG7dmlGjRjFv3rzzCt1Tp04lKSmJ5s2b89JLL/Hoo4+ecdlXXnmFTZs2MWHCBF566SXf9EceeYSXX36ZyZMnn/X5xdLT03nggQeIi4vjxx9/pEmTJgBMmDCBiy++mHvvvZfBgwcTGRlZ7v0Rqa3yXR6WH8imXoiFd39JYWdmoa/3KyYTXeNDub1dnO/IdpuYYL4/lqvQLSJyngpcHr7Yl8n/dmeS7/a+3naIDWF0Uiwto4MDXJ2IiFTo/KKUlBQiIiJOC51ff/01AL/73e98066//npMJhM///zzeW1r4MCBNG/e/JzLGYbB1KlTiYiI4Mknnywx78knnyQiIoKpU6eWaZtz584lIyODBx54wBe4AZo0acL9999PSkoKn3zySfl2RKSWyXK4+f5YLh9uS+WJbw9y14q9bM8oJLXAzW/pBTg9BlFBZrrGh9K3cBcPXFjy2u3YYKuvR6yIiJSdy2OwdH8Wf1lzgLk7Msh3GyRGBvFolwQe79pQgVtEpJqo0JHugoICgoKCSkzbtm0bmZmZtGnThoYNG/qmBwUFYbfbycrKqsgmzyk5OZlDhw4xePBgwsPDS8wLDw+nV69eLF68mP3799O0adOzrmvlypUADBo06LR5gwcPZuLEiaxatYrbb7/db/WLVHepBS5+Sy/wfR3MdZ62TJDZRIjFxMikWNrag2kYZsPlcrFo3+n3VEgrdBEdZKmK0kVEagWPYfDd0Vxm70jnaJ4LgPqhVm5ubadHQrjaf4mIVDMVCt3169fn0KFDHDlyhISEBACWLVsGwGWXXXba8vn5+URHR1dkk+eUnJwMQFJSUqnzk5KSWLx4McnJyecM3WdbV/G04mXOZNKkSUyaNOmcdRcrLCws8djlcuF0nh5qAqm4nqquy+VyVen2xHvmyJG8kiH7eMHp/w6Nw220s4f4vn5Jy+etrSm0s4ec9TrCQ7kOtmcUMu7C+MrcDZEarbr9DZDAKB4Hm4/nMH9vLnuyvY+jbGaGJUbRv1E4VrMJt8uFO5CFSq0TqPd9IlAzxp/Ndu57ZlQodHfr1o2FCxcyadIkXnnlFfLy8vj3v/+NyWTiiiuuKLHswYMHyc/Pp3Xr1hXZ5DllZmYCnDHcR0VFlVjufNdV1vVkZWVx8ODBc27rTNatW1emWgNh6dKlVbq9X375pUq3Vxd5DIN92Y4TITujgCxHyVO/TUCLqCDaFgXstjEhRJ1ypPrSBuF8uC2NGdvT+Evn+qUedfEYBjO3pxNpM9O9QVhl7pZIjbZo0aJAlyDVQJoplM1BLTi6NQMAq+Gmnes4bfJTcGz2sGRzYOuT2q+q3/eJnKw6j79hw4adc5kKhe577rmHBQsW8M9//pPPPvuM7OxsDh06RP369bnxxhtLLLtixQrg9Juu1XZRUVE0bty4zMsXFhaSkpLie9yzZ0969epVGaWdN6fTydKlS7nyyivL9MmOv1T2WRJ1kdNjsCuzkG0ZBfyaXsD2jALyi295W8RmNtEqOph2McG0s4eQFBNCqPXst4MIspi5u0M8kzYdZfKmY74+3cUO5TqYuT2dH4/nMb5zA4Isal8jciZDhw4NdAkSQEfzXczflcn6Y95e2xYTXN44guuaRxIVdO573YhUVKDe94lA7Rl/FQrdxdc1P/vss2zbtg2AuLg4PvroI0JDQ0ssO2PGDAAGDBhQkU2eU3EwO9PR4eJryssS4E5eV7169c5rPePHj2f8+PHn3FaxNWvW0KdPH99jq9VabQeYzWar0tqs1rrZx9nh9rD+aC7fH81lX1ALdm5NpVuDcC5tEF7usFrg8pCcWeg7kr3j5DuLFwm1mGgTE+I7kt0qOhibufzXB3apH8b4zvV55+cUHlp7gKToIApszfjxx2MkZzqItJkZ37kBXerrKLfI2VTXvwFSuTIL3Xy8K52vDmTjNrxnGTVzpXN/7wtoHBV6zueL+FtVv+8TOVlNH38VTjFPPfUUY8aMYf369cTExNC9e/fTgqjD4aBnz55ceumlXH311RXd5Fmd61rrc13zfeq6NmzYQHJy8mmhuzzrETlfPxzL5Z2fU8h2emgTHUSw4SbL4eatrSl8uC2NuzvEnzW0ZjvcbMsoYFu690j2nmwHp2RsomxmX8BuZw+hWUQQlvMI2aXpUj+cN+qF8t3RPL47mkOmyUKDIAvjLoyne4MwHeEWETlFnsvDoj2ZfL43k8Ki9l+d6oUyvEUkP6/eTP3QunXGoIhIbeCXQ4fNmjWjWbNmZ5wfFBR0WvuuypKUlESjRo1Yu3Ytubm5Je5gnpuby9q1a2nRosU5b6IG0K9fP2bOnMmSJUvo0aNHiXmLFy/2LSNSGX44lsukTce4JD7Md3r2okUbGHrJhaQ4YMb2NCZtOsr4zvXpUt87ztNOubP4gVLuLB4XYqWd3XuqeFt7CI3CbJgq8U63QRYzvRtFcGl8MIv2rWfohRfU6E8qRUQqg9NjsHx/Fp/syiDb6b2XRsuoIEa3iaVDbChOp5Pza7oqIiKBVuvO1zWZTNx55508++yzPPfcc7z00ku+ec899xw5OTk89thjJZ6Tl5fHvn37CAsLK/Hhwc0338yECRN44403+P3vf+/r1X3gwAGmTJlCXFwcN9xwQ9XsmJw3f56eXVUcbg/v/JzCJfFhvhuRnXzXxobhNv7cKZ6XfjzKv7Ycp2v9XLZlFHI8v/Q7i/uOZMeElOiRLSIigeUxDL45ksvcHem+1/CGYTZubm2ne4OwSv1QVEREqobf3n1/+umnLF68mL1795Kfn8/y5ct983Jzc/npp58wmUz07NnzvNY/depU1qxZA8CWLVt804p7affu3Zs777wTgL/97W8sXLiQl19+mY0bN3LJJZfw448/smTJErp168af//znEuv+7rvvGDBgAP369fOtD8ButzNlyhRuu+02LrnkEkaOHAnA7NmzSU1NZfbs2URGRp7X/kjVqOjp2YGy/mgu2U4Pt7SJ9d3522MYpJtCWHogh+QsJ7+lF5Dp8DaGWXM4F/Be85cYFUS7mBDfkexT7ywuIiKBZxgGm1PzmZWczt5sBwAxwRaGt4qhX6NIrH66zEdERAKvwqF7//793Hjjjfz444+A94/IqZ/KBgUFMXr0aA4cOMA333zDpZdeWu7trFmzhvfee6/EtLVr17J27Vrf4+LQHR4ezqpVq5g4cSLz589nxYoVNGzYkIceeoinn376tJu8nc2tt95KXFwcL7zwAtOmTcNkMtGlSxeeeOIJBg4cWO79kKpzPqdnVxaXxyDP5SH/pK88l0G++9RpHvJdBltT8wm1mpiy5ZjveXlOD66QNpCc4Vuv1eS9u3hMsIXb29UjKSaEsHPcWVxERAJrR2Yhs7an8Ut6AQChVhPXJsYwpFkUIXoNFxGpdSoUunNzcxk0aBDbtm2jSZMmXH/99UybNo28vLwSy9lsNv7whz8wceJEPvnkk/MK3dOnT2f69OllXj46OprJkyczefLkcy7bv39/DMM44/whQ4YwZMiQMm9bAq8sp2f/pXN9Jm86xjs/p/BGvdBSTzUvS1g+Md8oOc19Yvqpdwgvq91ZjhKPrYabC+qFcUFsGO3sIbSMCuLfW1PIdrrpFFf9jtiLiMgJh3OdzN6RxndHve+TrCYY3CyK61rEEKmzkkREaq0Khe5//etfbNu2jUsuuYRVq1YRHh7O3LlzTwvd4G0aPnHixBJHpkUqy6mnZ+c63fycks8eSwzLD+bgMEzkuTwEW0xkOz1M/O4wYVaz38LymQRbTIRazYRazIRaTYRZzd7HJ32FWc18cziHQreHW9vW802z4ebbr5ZwTaehJW5EllboIlpv1kREqq30Ahfzd2Ww8mA2nqL2X30aRXBTK7vusyEiUgdU6JV+/vz5mEwmJk2aVOIu4aW58MILsVgsbN++vSKbFCmTDcfyaBsTTMNwbzg9lu/itS2pENSM9dszTlt+T7bjtGknKw7LYScF5pND8onQbCLUUsq0oueVtRVXdJCZt7amkBBm8+2D0+nk1GPxh3IdbM8oZNyF8WVar4iIVJ08p4fP9mTwxd4sHEUf4l4SH8bI1naaRgYFuDoREakqFQrd27Ztw2Kx0KtXr3Mua7FYiImJISMjoyKbFCmTPJcHe8iJ4R1ps9Ay0kZuRhpNE+oTbrP4QvEPx/JweTwMb20vCtQnh2kTIeUIy/5yaYNwPtyWxoztab7T40/lMQxmbk8n0mamewOdWi4iUl043B6W7s9m4e4Mcoraf7WJCWZUUizt7CEBrk5ERKpahUJ3YWEhoaGhWCxlO7U1Ly+PkBD9sZHKF2Y1k15won1WXKiVp7s2YNGiH07rE/1zWj7RQUH0TIgIRKmlCrKYubtDPJM2HWXypmO+G8EVO5TrYOb2dH48nsf4zg2qbeszEZG6xGMYrD6Uw7yd6aQWeLtLNA63MTLJTpd4tf8SEamrKhS6GzRowP79+8nIyCAmJuasy/7888/k5+fTvn37imxSpEy61g/jra0pHM51+k7PLk11Pj27S/0wxneuzzs/p/DQ2gMkRQdRYGvGjz8eIznTQaTNzPjODaplyzMRkbrEMAw2puQza3saB3K9N+2MDbZwU2s7fRpGVPnZUiIiUr1U6PBY7969AW/f6nN55ZVXMJlMDBgwoCKbFCmTSxuEE2kzM2N7Gp4z3Jm+Jpye3aV+OG/0bcq4C+OJDrJQaLIQHWRh3IXxvNG3qQK3iEiAbc8o4NnvD/PqxqMcyHUSbjUzOsnOpN5N6N84UoFbREQqFrrHjRuHYRhMnDiRrVu3lrqMw+Hg0Ucf5YMPPsBkMnHvvfdWZJMiZVJ8evaPx/OYvOkYh3OdJeYfynUwedMxfjyex90d4qv16dlBFjO9G0XwwIX1GODYzQMX1qN3o4hqXbOISG13IMfBPzceZeJ3h9mWUYjNbOLaxGgm92nCtS1i9BotIiI+FTq9/LLLLuOBBx7gjTfeoEePHgwZMoScnBwAHnvsMfbu3cuyZctISUkB4IknntDp5VJldHq2iIj4W2qBi3k70vn6UA4G3vZf/RtHMLyVndgQtf8SEZHTVfivw2uvvUZUVBQvvfQSH3/8MQAmk4mXX34Z8F7nZLVaefLJJ3nyyScrujmRculSP5w36oXy3dE8vjuaQ6bJQoOi07O7NwjTkQgRESmTHKebT3dnsnhfFs6i9l/d6odxc2s7jSPU/ktERM6swqHbZDLx3HPPceeddzJ9+nTWrl3LoUOHcLvdJCQk0KtXL37/+9/TsmVLf9Qr4pObm0tWVlaZlr0oAi4ItrHkt58Z1L0xNpuHgtwcCiq5Rn9yOp3k5eWRlZVV4u7rNYXqD5yaXDuofoDIyEjd+TpACt0eFu/L4tPdmeS5vO2/2tlDGJ1kJylGHVlEROTc/HYeVPPmzXn66af9tTqRcxoyZEigSxARqRKZmZlERUUFuow6xe0xWHUom/k7M0gv9Lb/ahphY1RSLJ3jQvUhiIiIlJnOrZUa68svv2TVqlUArFq16pw/Fzt06BCZmZll/jp5XeVd5tTpZ3tcG+t/5513AFi8eLFf6k9JSWHGjBmkpKTUyPor8ruvSP3nW7vqLzl9+fLlACxfvrzK6i/+ioyMRKqGYRh8fzSXv31zkKm/pJJe6CYuxMq9F8bxYs/GXKx+2yIiUk6644fUGB07dmT16tUlHu/cuROAiIgI3/Qz/VwsKiqK8PDwMm+3eB0RERFnPNJ0pmVOnX62x7Wx/rAw703qTq63ovWHhYURFRVV4jTdmlR/WeeXNv186z/f2lV/4OuXqvVrWj4zk9PZkVkIQITNzA0tYxjYNAqbWn+JiMh58kvozs7O5rPPPmPz5s2kp6fjdDrPuKzJZOI///mPPzYrdUx0dLSvN7yIiIi/7Mt2MCs5jU0p+QAEm01clRjNNc2jCbPppEAREamYCofud955h7/+9a/k5ub6phmGcdpyJpMJwzAUusWvGjZsyNNPP03Dhg0Bzvjzo48+yosvvuiXbZRnmVOnn+txbau/Q4cOPP300yQkJJxX7XWh/rLWfr71V2TsqP6S0xMSEhg5cqRvPFRF/VK5juc7mbsjg7WHve2/LCYY0DiSG1vFEBOskwFFRMQ/TEZpCbmM5syZw6hRowDv6Zc9e/akQYMGWK1n/0M1bdq0891krbdmzRr69Onje7x69epqd3TX6XSyaNEihg4dWmPuJJybm+s77TMnJ6fGneKp+r0CNfZq8u+/JtcO1av+8xl/1al+OSHL4WbhrgyW7s/CVfQuqEeDcEa0ttMwvHr+XauJf3uldtDYk0CqLeOvQh/jvvrqqwBcddVVzJo1Szd6ERERkWqrwOXhi32Z/G93Jvlub9ruEBvC6KRYWkYHB7g6ERGprSoUun/++WdMJhP//e9/FbhFRESkWnJ5DFYczObjnRlkOrztvxIjgxjdJpaO9UIDXJ2IiNR2FQrd4eHhBAcH06BBA3/VI1IpwsPDS73XQE2h+gOrJtdfk2sH1S8V4zEMvjuay+wd6RzNcwFQP9TKza3t9EgIx6zWXyIiUgUqFLo7derEypUryc7O1pFuERERqTa2puYzMzmN3VkOAKKCzNzY0s7lTSKxqv2XiIhUoQr1wfjzn/+M2+3mX//6l7/qERERETlvu7MKefGHw7zwwxF2ZzkIsZi4qVUMr/VuyqBmUQrcIiJS5Sp0pPvqq6/mySef5MknnwTgwQcfJDRU10aJiIhI1Tqa52TOjnTWHfG2MLWYYGDTKK5vEUN0sCXA1YmISF1W4SaUzzzzDBEREUyYMIHnnnuO9u3bn/VUc5PJxPLlyyu6WREREREyC918vCudrw5k4zbABFzWMJybWtlpEFZz28uIiEjtUaHTywEef/xxHnvsMUwmE/n5+fzwww+sXLnyrF8i1d3rr79O8+bNCQkJoXfv3vz000+BLqlcPv74Y6688kpiY2MxmUzs2bMn0CWVy4svvkjXrl2JjIykQYMG3HzzzTVmHyZPnkyHDh2IiIggJiaGyy+/nPXr1we6rPNy7733YjKZmDJlSqBLKbOJEydiMplKfHXt2jXQZZXLvn37uPnmm7Hb7YSHh9OtWzcOHjwY6LKqnTyXh3k70vnzmv0s3e8N3J3qhfL3Ho24r2N9BW4REak2KnSk+7///S8vvvgiAC1atOCKK66gQYMGWK0VPoAuEjAzZsxgwoQJvPPOO3Tp0oV//OMfDB48mO3btxMVFRXo8sokNzeXvn37MmzYMB544IFAl1Nuq1at4oEHHqBbt24UFhby8MMPc9VVV/Hjjz8GurRzat68OZMmTaJ169YUFhby2muvMXjwYHbu3Em9evUCXV6Z/e9//2PdunU0atQo0KWUW6dOnfjyyy99j222mhO+UlNT6d27N0OGDGHZsmXExMTwyy+/EBysHtLFnB6D5fuz+GRXBtlODwAto7ztvzrE6hI3ERGpfiqUjqdMmYLJZOKOO+5g6tSpmM0VPnAuEnCTJ0/mj3/8I7fffjsAU6dOJSEhgRkzZvDHP/4xwNWVzW233QbA1q1bA1zJ+Tk5MAG8++67tGzZkl9++SVAFZXdjTfeWOLxq6++yrvvvsvWrVvp169fgKoqn6NHj3LvvfeyaNEirr322kCXU25Wq5WEhIRAl3FeXn75ZVq0aME777zjm9aqVasAVlR9eAyDb47kMndHOsfzve2/GobZuLm1ne4NwjCp/ZeIiFRTFUrJ27dvB2DSpEkK3FJlPvzwQ+655x66du1KcHAwJpOJ6dOnn/U533//PUOHDiUmJobw8HB69OjBnDlzTlvO4XCwceNGBg4c6JtmtVrp378/69atqxH7UBWquv7MzEwAYmNjK1p6ldbucDh45513sNvtdOzYscK1V1X9Y8eO5U9/+pPfaj5ZVdT/66+/0rBhQ1q3bs3YsWM5cuSI3+pfuXIl48aNq7T6P/vsMy655BKGDx9O/fr16datGx9//LHf6q+JDMPgp5Q8Hv/2EG9uOc7xfBcxwRb+0L4eL1/WmEsTwhW4RUSkWqvQke7w8HCCgoKIiYnxUzki5/bEE0+wd+9e4uLiaNiwIXv37j3r8itWrGDw4MGEhIQwatQoIiMjmT9/PiNHjmT//v089NBDvmVTUlJwu900aNCgxDrq16/Pzp07a8Q+VIWqrN/tdvPXv/6VoUOH0qRJEzZv3lzta1+9ejVXXXUV+fn5JCQksHTpUr98YFAV9U+ZMoXc3NxKG1OVXf+ll17K9OnTadeuHQcPHuSpp57i8ssvZ+PGjX45Rfujjz7i+PHjlVb/7t27eeutt3j00Ud54oknWL58OSNGjGDFihX07du3wvXXNDsyC5m1PY1f0gsACLWauC4xhiHNowi26MN+ERGpIYwKuOaaawyLxWKkpKRUZDVyktWrVxuA72v16tWBLuk0DofDWLBggeFwOAKy/aVLlxp79uwxDMMwXnzxRQMwpk2bVuqyTqfTaNWqlREcHGxs3LjRNz0jI8No06aNERQU5FuXYRjGwYMHDcD47rvvSqzn3nvvNQYNGlQj9uFkW7ZsMQBj9+7dfqu9Kuv3eDzGnXfeaSQlJRnHjh3zy9iritrz8vKM5ORk49tvvzX+8Ic/GC1btjSOHz9+3jVXVf2//vqrUb9+/RLjpXnz5sYbb7zhl9oru/7SHDt2zAgJCTHmzZtX4dodDofxzDPPGMnJyZVWv81mM3r37l1i2nXXXWf87ne/q3D9NcmhHIcxedMRY/TiXcboxbuM25bsMj78LcXIKnQFurSACfTfXqm7NPYkkGrL+KvQx8R/+9vfAPj73/9ekdWIlMvAgQNp3rx5mZb96quv2LlzJ7fccgudO3f2TY+Ojuaxxx7D4XDw3nvv+abHxcVhsVg4evRoifUcO3bMr9eIVuY+VIWqqN8wDMaNG8eyZctYvnw58fHxNab20NBQWrduzaWXXuq738W0adOqff3ffvstx48fp3Xr1litVqxWK3v37uXBBx8s8fzqWn9p4uPjSUxMZPfu3RUp26dTp06VWn9CQgJt27YtMe2CCy5g3759Fa69JkgvcDH1lxQe/uYA3x3NwwT0bRTBpN5N+V3bekQGqd+2iIjUPBU6vbxPnz68/fbb3H///eTl5TFhwgRatGjhr9pEKqy4Rd2gQYNOmzd48GDAe6fsYkFBQVx88cUsX76ca665BgCXy8XKlSt5/vnnK7/gUpR3H6qb86nfMAzuu+8+Pv/8c1atWkXTpk0rvc7S+Ot3bxgGhYWFfq2tLMpb//XXX39ae63BgwczZswYxo4dW3mFnoE/fv/p6ens3buXxMREf5d3TudT/2WXXcaOHTtKTNu+fXuZg35Nlet089meTL7cm4XDYwBwSXwYI1vbaRoZFODqREREKqZCobtly5YAWCwW3n33Xd59911iY2OJjIw843NMJpNfr40VOZvk5GQAkpKSTpuXkJBARESEb5lif/nLX/jDH/5Aly5duOSSS3j11VexWq3ccsstVVLzqc5nH9LS0ti3b5/v/9ovv/xCRkYGzZo189u1xWV1PvXfd999zJw5k88++4zQ0FDfjbDO9tpSGc6n9gkTJnDdddfRpEkT0tLSePPNNzlw4ADDhw+vkppPVt76Y2JiTrtHh81m892UrKqdz+//4Ycf5tprr6VZs2YcOHCAxx57jMaNGzN06NAqqflk5/v606tXL/75z38ybNgwli1bxmeffVatP1irCIfbw9L92SzcnUFOUfuvNjHBjEqKpZ09JMDViYiI+EeFQveePXtOm5aamkpqauoZn6M7jEpVKr7rdXR0dKnzo6KifMsUu+WWWzh+/DiPPfYYR48epWvXrixevDhgPbrPZx8+/fTTEkcmr776agCmTZvGmDFjKqfQMzif+t966y3AezbNyZYuXVoJFZ7Z+dR+6NAhRo0axbFjx4iNjaVbt26sXr2aCy64oNLrPdX51F+dnE/9+/fvZ9SoUaSkpNCgQQP69evHBx98QFhYWKXXe6rzqf/SSy9l7ty5PP744zzxxBO0adOGuXPnctlll1V6vVXJYxisPpTDvJ3ppBa4AWgcbmNkkp0u8Wr/JSIitUuFQre/rlEUqW4efPBBHnzwwUCXcd7GjBlT5eHanwzDKHW60+lk0aJFVVxN+XzwwQeBLsGvSvtwtTqbNWtWoEuosBtuuIEbbrgh0GVUCsMw+PF4PrOT0ziQ6wQgNtjCTa3t9GkYgcWssC0iIrVPhUL3HXfc4a86RCpF8RGmMx3Ny8rKwm63V2VJ5VbT96Em11+TawfVH2g1vX5/255RwMztaWzL8N7fINxq5roW0QxuFkWQ2n+JiEgtpr9yUqsVX0t56nWTAEeOHCEnJ6fU6y2rk5q+DzW5/ppcO6j+QKvp9fvLgRwH/9x4lInfHWZbRiE2s4lrE6OZ3KcJ17aIUeAWEZFaT3/ppFbr168fAEuWLDlt3uLFi0ssU13V9H2oyfXX5NpB9QdaTa+/olILXLy99TgTvjnID8e97b8GNI5kcu8mjG4TS4RN7b9ERKRuUOiWWu2KK66gZcuWzJgxg02bNvmmZ2Zm8sILLxAUFMTtt98euALLoKbvQ02uvybXDqo/0Gp6/ecrx+lmxvY0xq85wKpDORhAt/phvNKrMXd1iCM2pEJXtomIiNQ4Zf7LZ7F4P5Fu164dP//8c4lp5WEymXC5XOV+nkixqVOnsmbNGgC2bNnim1bcE7d3797ceeedAFitVqZOncrgwYPp27cvo0aNIjIykvnz57N3715effXVgPTvren7UJPrr8m1q/7A17906VLmz5+P2WyukfVXpkK3h8X7svh0dyZ5Lm/7r3b2EEYn2UmKUfsvERGpw4wyMplMhslkMi644ILTppXny2w2l3WTddLq1asNwPe1evXqQJd0GofDYSxYsMBwOBwB2f4dd9xR4nd06tcdd9xx2nPWr19vDBkyxIiKijJCQ0ON7t27G7Nmzar64ovU9H0IVP3+GHv63av+8+VwOIwBAwbU2Pori8vtMZbvzzTGrdxrjF68yxi9eJfxt7X7jR+P5RoejyfQ5dUagf7bK3WXxp4EUm0ZfybDOENvnlOsWrUKgLCwMLp161ZiWnnV5mvYKmrNmjUlehOvXr2a3r17B7Ci0xW3bRo6dCg2my3Q5UgdorEngaTxV5JhGGw4lses5HQO53nbf8WFWBnROoZeDSMwq9e2X2n8SaBo7Ekg1ZbxV+bTy/v168e+fftKnFKu8CwiIlL3/JqWz8zkdHZkett/RdjM3NAyhoFNo7Cp17aIiEgJ5bqbSWJiIg0bNuTgwYOVVY+IiIhUU/uyHcxKTmNTSj4AwWYTVyVGc03zaMJsujeriIhIacp9C9Eyno0uIiIitcTxfCdzd2Sw9rD3buQWk7f9142tYogJ1t3IRUREzkZ/KUVERKRUWQ43C3dlsHR/Fq6iz9x7NAhnRGs7DcNr7rV1IiIiVUmhW0REREoocHn4Yl8m/9udSb7bm7Y7xIYwOimWltHBAa5ORESkZlHoFhEREQBcHoMVB7P5eGcGmQ43AImRQYxuE0vHeqEBrk5ERKRmUugWERGp4zyGwXdHc5m9I52jeS4A6odaubm1nR4J4Wr/JSIiUgHlDt1paWlcfvnl571Bk8nE8uXLz/v5IiIi4j9bU/OZmZzG7iwHAFFBZm5saefyJpFY1f5LRESkwsodup1OJytXriz3hkwmE4ZhYKqiT8unT5/O2LFjz7rM5Zdffs4PAFauXMmAAQPOOH/atGmMGTPmfEoUEREJmN1ZhcxKTmNLagEAIRYT1yRGM7R5NCFWtf8SERHxl3KHbpvNRs+ePSujFr/q3LkzTz/9dKnz5s2bx88//8zgwYPLvL5+/frRv3//UrcjUlclJiYSEhLC1q1bsVq9Lyddu3bl1VdfLfX/y/kaM2YMnTt35r777vPbOs/l22+/5a677sJqtfLSSy+VeL1YuXIlV111FW3btsXj8RAaGsrrr79Ojx49qqw+gBEjRjB+/Hh69uzp+x39+c9/Pu/1TZkyhaysLB577DH/FSnVztE8J3N2pLPuSC7gbf81sGkU17eIITrYEuDqREREap9yh+7Y2FhWrFhRGbX4VefOnUsNxA6HgylTpmC1WrnjjjvKvL7+/fszceJE/xUoUksUFhbyn//8h3vuuSfQpZyVy+XyfTBQFu+99x633HILjz76aKnz27Zty6ZNmwBvWP3973/PL7/84o9Sy+S7774jLS3Nrx+C3n333VxwwQXcd999REdH+229Uj1kFrr5eFc6Xx3Ixm2ACbisYTg3tbLTIEztv0RERCpLnTt/bMGCBaSmpnLNNdfQoEGDQJcjUuNNnDiR5557jry8vNPmjRkzhtdee833+K9//avvw6uJEydy8803c+2119KmTRuuueYatm7dyuDBg2nTpg2jR4/G4/H4nrt582b69u3LuHHj+P3vf09+fj4A2dnZ3HXXXXTv3p2LLrqIu+++G4fDe21q//79+dOf/kTPnj0ZNGjQafUdO3aMG2+8kY4dO3LhhRfy9ttvA/DSSy8xe/ZspkyZQufOncnIyDjr7+CKK65g7969vscffPABF110ERdddBFXX301Bw8eBOCyyy7jm2++AeBvf/sbjRs39j2nZcuW7Nu3j+TkZHr16kWnTp3o2LEjTzzxRKnbfPvtt7nllltKnZeTk8Pvf/97LrzwQi688EKeeeYZ37zffvuNnj170qFDB2688UYGDRrE9OnTAQgKCmLQoEHMmDHjrPsrNUuey8O8Hen8ec1+lu73Bu5O9UL5e49G3NexvgK3iIhIJatzoXvq1KkA3HnnneV6XnJyMq+99hovvvgiH3zwge9NtEhd16lTJwYMGMDkyZPL/dwNGzbw/vvvs23bNrKzs7nzzjuZN28ev/zyC7/++itffPGFb9n169fz+eef88Ybb5CWlubb3kMPPUSfPn347rvv+Omnn/B4PLz++uu+523fvp2vv/6ar7766rTtP/DAA7Rt25YtW7bw1Vdf8fzzz/Ptt9/yyCOPcN111/Hwww+zadMmYmJizrof8+bNY9SoUQBs3bqVhx9+mC+++ILNmzdz2WWX+V5vBg4cyLJlywD46quvaNKkCb/88gs7d+7EarXSrFkzpkyZwjXXXMNPP/3Eli1bGD9+fKnbXLlyJZdeemmp85577jkKCwvZvHkz69evZ8GCBcyePRuA2267jbvvvpuff/6Zv//973z99dclntuzZ0/d7LKWcHoMvtybyV9W7+fjXRkUug1aRgXxeNcEJnRJIDFK/bZFRESqQp1qGbZ3716WL19OkyZNGDJkSLmeO2PGjBJHf6xWKw888AD/+Mc/sFh0DZzUbc899xzdu3fnj3/8Y7meN2jQIOx2OwCXXHIJwcHBREZGAnDxxReTnJzsW/bmm28mMjISi8XC2LFjefPNN3nsscdYsGAB69atY9KkSQDk5+eX+D956623YrOVfiRv2bJl/PDDDwDUr1+fG2+8kWXLlpXp2uxt27bRuXNnjhw5gsvlYv369QCsWLGCIUOG+I5ijxs3jmeffRa3283AgQN54oknGDduHFarlREjRrBs2TKCg4O54oorAOjbty8PP/wwOTk59OvXj4EDB5a6/QMHDpzxbJ1ly5bxz3/+E7PZTHh4OLfffjtLly7lqquuYtOmTdx+++0AXHDBBfTu3bvEcxMSEjhw4MA591+qL49h8M2RXObuSOd4vrf9V8MwGze3ttO9QViV3dBUREREvOpU6J42bRoej4cxY8aUOSjHx8fz0ksvcc0115CYmEhubi7r1q3jkUceYfLkyZhMJv75z3+e8fmTJk3yhYGyKCwsLPHY5XLhdDrL/PyqUFxPdatLAsPpdNK4cWNGjRrFs88+i2EYvnFrNptxOBy+sZKXl0doaChOpxO3201QUJBvnslkwmazlXhcWFiI0+nE4/Hgdrt989xut2/bhmEwa9Ys2rRpc1pdhmEQEhJy1rHqdDp98w3D8G3n1G2ezOVy0aZNG77//nucTicPPPAAt9xyC6tXr8btduPxeHzPc7lcvu107dqVrVu38vHHH9OvXz/69evHxIkTCQ4OZsSIETidTq677jq6devGsmXL+L//+z8mT57Mp59+eloNYWFhZGdn+47Cn1zvyf8GxfNOrql4/4qdvJ85OTnn/J3VVdX9tc8wDLakFTJ3Vyb7crw1xgSZub5FFH0SwrGaTb7xKDVPdR9/Untp7Ekg1YTxd6aDOyerM6Hb4/Ewbdo0TCYTv//978v8vA4dOtChQwff4/DwcIYNG8all17KRRddxP/93/8xYcIE6tevX+rzs7KyKnQq+rp168jMzDzv51empUuXBroECbC8vDzWrFnDoUOH6NatG/fffz8Wi4Vvv/2W3NxcXC4Xn376KW3btiUrK4uPP/6Y/v37s2jRIpKTk8nNzWXRokUA7Nq1i5CQEN/j/fv3YxgGixYt4sCBA6xatYr27dsTFBTEpEmTaNOmDYsWLeLiiy/mwQcfZNy4cVgsFnJycsjOzqZhw4akpqbyww8/nPHF8IILLuCxxx7j1ltvJTMzk5kzZ/K3v/3Nt02bzear52RbtmwhKyvLN2/w4MEsXLiQp59+moYNG/LZZ5/x4YcfEhsby/z587nwwgtZvHgxAC1atOCJJ57ggQce4MCBA/zwww/k5eVxww03sGjRIg4dOkRCQgL16tXjqquu4pFHHim1hsaNG/Phhx/SqVMngBL1JiYm8vzzz5OTk0NhYSFvvvkmN954I2vWrKF58+ZMmDCByy+/nIMHD7J69Wrat2/v28bChQuJjIwsdZviVR1f+1JNoWy2NeSYJQIAm+GmnesYbfJTyN9ksCTA9Yn/VMfxJ3WDxp4EUnUef8OGDTvnMuUK3StWrCAoKOi8CwqkZcuWsW/fPq644gpatGhR4fUlJCQwbNgwpk6dyvr167n22mtLXS4qKqrEzZLOpbCwkJSUFN/jnj170qtXrwrX609Op5OlS5dy5ZVXlumTHam9wsLC6N27t69TwM6dO3nmmWfo0aMH/fr1o0ePHowaNYoJEybQsmVL+vfvT1JSEkOHDmXDhg1kZmYydOhQAFatWkV4eLjv8cKFC2nbti1Dhw5l/vz5NGvWjNdff519+/bRv39//vWvfxEaGkrfvn15/PHHefLJJzGbzVitVl588UWuuOIKJk2aRJcuXXzrPFWXLl24//77efzxxzEMg2eeeYa77roLgPnz59O+fftSnxseHs7cuXNLzMvOzub1119nw4YNREZG+s5wadq0KfPnz/e9Dmzfvp2nn36av/zlLwQHB9OvXz+2b9/OyJEjAXj55Zd54403CAoKwuPx8Pbbb5daw+7du9m/f79v3sn19u3bl7/85S88/vjjAPzud7/jySefBLxt3u6++26WLVtGq1at6N69O3379vWtZ/LkyUycOLHave5UB9Xxte9wnpN5u7LYcNx7Y0GrCQY2ieDa5pFE2JoHuDrxp+o4/qRu0NiTQKot489kGIYR6CKqws0338zcuXOZOXOm74ZHFfXoo4/y0ksv+XWda9asoU+fPr7Hq1evPu2ay0BzOp0sWrSIoUOH1ujBLzWPxt4JOTk5XHbZZaxbt47w8PByPS88PByTycTu3bvp2bMn33//PU2bNuWXX37hnnvuYfXq1ZVYec1VncZfeoGL+bsyWHkwG09R+68+jSK4qZWduNA6cxJbnVKdxp/ULRp7Eki1ZfzVib/MqampLFy4kNjYWG644Qa/rbf4xkmJiYl+W6eISFlEREQwefJkdu/ezYUXXljm533zzTc8/PDDgPda7smTJ9O0aVPAe0p/cds0qZ5ynW4+25PJl3uzcHi8n5lfEh/GyNZ2mkbWzDPRREREars6Ebo/+OADHA4Ht956K8HBpbdISUlJISUlhbi4OOLi4nzTf/jhB7p06XLa8q+//jorVqwgKSmJbt26VVrtIiJnUnzH8/IYNGhQqT3LwXttulRPDreHpfuzWbg7gxyn9yZ4bWKCGZUUSzt7SICrExERkbOpE6H7P//5D3D23txTpkzhmWee4emnn2bixIm+6cOHD8dms9G1a1eaNGlCbm4u3377LRs3biQmJoYPP/xQLcNERKRSeAyD1YdymLczndQC7137G4fbGJlkp0u82n+JiIjUBLU+dH/33Xds3bqV7t2707Fjx3I//95772Xx4sV8/fXXpKamYjabad68OX/+85956KGHaNKkSSVULSIidZlhGPx4PJ/ZyWkcyPW2SYkNtnBTazt9G0VgVtgWERGpMWp96O7evTtluVfcxIkTSxzhLjZhwgQmTJhQCZWJiIicbntGATO3p7EtoxCAcKuZYS1jGNQ0kiCLOcDViYiISHnV+tAtIiJSExzIcTA7OZ0fjucBYDObGNIsimtbRBNh02VMIiIiNZVCt4iISAClFriYtyOdrw/lYOBt/9W/cSTDW8UQG6I/0yIiIjWd/pqLiIgEQI7TzcJdmSzZn4WzqP1Xt/ph3Jxkp3G42n+JiIjUFmUO3c8++6zfNvrUU0/5bV0iIiI1SaHbw+J9WXy6O5M8l7f9Vzt7CKOT7CTFqP2XiIhIbVPm0D1x4sQKtyYxDAOTyaTQLSIidY7bY7DqUDbzd2aQXuht/9U0wsaopFg6x4Wq/ZeIiEgtVebQ3bdv3zO+Idi0aROZmZkANG7c2NdG6+DBgxw4cACAmJgYOnXqVNF6RUREahTDMPj+WB6zk9M5nOdt/xUXYmVE6xh6NVT7LxERkdquzKF75cqVpU5/9NFHWbVqFaNHj2bixIkkJSWVmL9jxw6eeeYZPvroI3r27MkLL7xQoYJFRERqil/T8pmZnM6OTG/7rwibmRtaxjCwaRQ2s8K2iIhIXVChG6nNnz+fV155hXHjxjFlypRSl2ndujUffPAB0dHRvPzyy3Tt2pUbb7yxIpsVERGp1vZlO5iVnMamlHwAgs0mrkqM5prm0YTZ1GtbRESkLqnQX/4pU6ZgMpmYOHHiOZctXuZM4VxERKSmO57v5M0tx3l03UE2peRjMcHAJpFM7tOEm1vbFbhFRETqoAod6d68eTPR0dHExcWdc9m4uDhiYmL46aefKrJJERGRaifL4WbhrgyW7s/C5e3+RY8G4YxobadhuC2wxYmIiEhAVSh0FxYWUlhYSE5ODhEREWddNicnh6ysLIKDgyuySRERkWqjwOXhi32Z/G93Jvlub9ruEBvC6KRYWkbr752IiIhU8PTytm3b4vF4ynTK+JQpU3C73bRt27YimxQREQk4l8dg6f4s/rLmAHN3ZJDvNkiMDOLRLgk83rWhAreIiIj4VOhI95gxY3jwwQd54oknKCws5KGHHjrtiHdeXh6vvvoqzz77LCaTibFjx1aoYBERkUAxgPXH8pi/O4ujeS4A6odaubm1nR4J4Wr/JSIiIqepUOi+7777+Pzzz1myZAnPPvss//jHP+jatSuNGzcGvH26N2zYQH5+PoZhcOWVVzJu3Di/FC4iIlKVfk4rYGlwa9J/TgMgKsjMjS3tXN4kEqvaf4mIiMgZVCh0m81mPv30Ux555BGmTJlCXl4eX3/9NaaiT/oNw3t9m8Vi4b777uPll1/GbNadW0VEpObYnVXIrOQ0tqQWgDmMEIuJaxKjGdo8mhCr/qaJiIjI2VUodAMEBQUxadIkHn74YebNm8eGDRs4duwYAPXr16dr164MHz6cRo0aVbhYERGRqnI0z8mcHemsO5ILgMUELZ0p/KlXR+qFhwS4OhEREakpKhy6izVs2JAHHnjAX6sTEREJiMxCNx/vSuerA9m4DTABlzUM5/rmkWxYsZmooM6BLlFERERqEL+FbhERkZosz+Vh0Z5MPt+bSWFR+69O9UIZmWQnMSoYp9MZ4ApFRESkJlLoFhGROs3pMVi+P4tPdmWQ7fQA0DIqiNFtYukQGxrg6kRERKSm81vo/uabb1izZg0HDhwgNzfXdxO1U5lMJv7zn//4a7MiIiLnxWMYfHMkl7nJ6Rwv8Lb/ahhm4+bWdro3CPPdFFRERESkIiocupOTk7nlllv48ccfS0w3DOO0NyzF0xS6RUQkUAzDYHNqPrOS09mb7QAgJtjC8FYx9Guk9l8iIiLiXxUK3ampqVx++eUcPHiQBg0a0K9fP+bMmUNoaCjDhw/nyJEjrF+/nuzsbOLi4rj66qv9VbeIiEi57cgsZNb2NH5JLwAgzGrm2sRohjSPItii9l8iIiLifxUK3a+99hoHDx7k0ksvZfny5YSFhTFnzhyio6N5//33AcjNzeXZZ5/lH//4B6Ghobz55pt+KVxERKSsDuU6mJOcznfH8gCwmmBwsyiuaxFDZJAlwNWJiIhIbVah0P35559jMpl44YUXCAsLK3WZ8PBwXn75ZRwOB//3f//HgAEDGDFiREU2KyIiUibpBS7m78pg5cFsPEXtv/o0iuCmVnbiQnUvUREREal8FTqXbufOnZhMJvr06VNiusPhOG3ZRx55BIB33nmnIpsUERE5p1ynm1nJafxlzQG+OuAN3JfEh/FSz8b88cJ4BW4RERGpMhV61+F0OrHb7VitJ1YTFhZGdnb2acs2aNCA6OhoNm/eXJFNioiInJHD7WHp/mwW7s4gp6j9V5uYYEYlxdLOHhLg6kRERKQuqlDobtSoEYcPHy4xrUGDBuzZs4ddu3bRsmVL33Sn00lWVlaJgC4iIuIPHsNg9aEc5u1MJ7XADUDjcBsjk+x0iVf7LxEREQmcCp1e3rx5cwoKCjhw4IBvWrdu3QD48MMPSyw7ffp0PB4PjRs3rsgmRUREfAzD4IdjeTzyzUHe/jmF1AI3scEW7u4Qx8uXNaZr/XAFbhEREQmoCh127tOnDytXrmTlypXceuutANx2223MmTOH559/nqNHj9K5c2d++ukn3n33XUwmE9dff70/6hYRkTpuW3oBM5PT2J5RCEC41cywljEMahpJkNp/iYiISDVRodA9YsQI3nvvPZYvX+4L3VdffTWjRo1i1qxZ/Pvf//YtaxgGF1xwAU899VTFKhYRkTrtQI6D2cnp/HDc2/7LZjYxpFkU17aIJsKm9l8iIiJSvVQodHfo0IHdu3efNv2jjz5iwIABzJ49m/379xMdHc2QIUN46KGHiI6OrsgmRUSkjkotcDFvRzpfH8rBwNv+q3/jSIa3iiE2RPcLERERkeqpUt6lmEwm7rrrLu66667KWL2IiNQhOU43C3dlsmR/Fk6PAUC3+mHcnGSncXhQgKsTEREROTsdGhARkWqp0O1h8b4sPt2dSZ7L2/6rnT2E0Ul2kmLU/ktERERqBr+G7uPHj7N3717y8vLo27evP1ctIiJ1hNtjsOpQNvN3ZpBe6G3/1TTCxqikWDrHhepu5CIiIlKj+CV0f/rpp0ycOJGffvoJ8J5e7nK5fPPT09MZPXo0ALNnz9Z13SIichrDMPj+WB6zk9M5nOcEIC7EyojWMfRqGIFZYVtERERqoAqH7pdeeonHH38cwzDOuIzdbic0NJRPP/2UefPm8Yc//KGimxURkVrk17R8ZiansyPT2/4rwmbmhpYxDGwahc2ssC0iIiI1V4UamX777bc8/vjjWK1WJk+eTEpKCg0aNCh12VtvvRXDMFi6dGlFNikiIrXIvmwHr/x4hOc2HGFHZiHBZhPXt4zhtd5Nuap5tAK3iIiI1HgVOtL9+uuvA/Doo4/y4IMPnnXZfv36AbBx48aKbFJERGqB4/lO5u7IYO1hb/sviwkGNI7kxlYxxATrHp8iIiJSe1Tonc3atWsBuP/++8+5bFxcHOHh4Rw6dKgimxQRkRosy+Fm4a4Mlu7PwlV0VVKPBuGMaG2nYbgtsMWJiIiIVIIKhe5jx44RGRlJXFxcmZYPDg4mOzu7IpsUEZEaqMDl4Yt9mfxvdyb5bm/a7hAbwuikWFpGBwe4OhEREZHKU6HQHR4eTnZ2Nm63G4vFctZlc3JyyMjIID4+viKbFBGRGsTlMVhxMJuPd2aQ6fC2/0qMDGJ0m1g61gsNcHUiIiIila9Cobtt27asX7+ezZs3c/HFF5912QULFuDxeOjcuXNFNikiIjWAxzBYfzSXOTvSOZrnbSFZP9TKza3t9EgIV/svERERqTMqFLqvu+46vv32W1588UXmzJlzxuUOHDjAI488gslkYvjw4RXZpIiIVHNbU/OZmZzG7iwHAFFBZm5saefyJpFYdTdyERERqWMq1DLs/vvvp3HjxsyfP5/bb7+drVu3+uY5nU6Sk5OZNGkSXbp04dChQ7Rp04Y77rijwkWLiEj1szurkBd/OMwLPxxhd5aDEIuJm1p5238NahalwC0iIiJ1UoWOdEdERPDZZ58xePBgPvzwQz766CPfvJCQEN/PhmHQqFEjFixYgM2mu9OKiNQmR/OczNmRzrojuYC3/dfAplFc3yKG6OCz3+9DREREpLar0JFugM6dO/PTTz8xduxYgoODMQyjxJfNZmPMmDFs2LCBtm3b+qNmERGpBjIL3Uz7NYW/rj3AuiO5mIBeDcN5tVcT7mhXT4FbREREhAoe6S6WkJDAf/7zH958801++OEHDh06hNvtJiEhgW7duhEWFuaPzYiISDWQ5/KwaE8mn+/NpLCo/VeneqGMTLKTGKX2XyIiIiIn80voLhYcHMxll112xvlOp5O3336b+++/35+bFRGRKuD0GCzfn8UnuzLIdnoAaBUVzKg2djrEqv2XiIiISGn8GrrPxO1285///Ie///3vHDx4UKFbRKQG8RgG3xzJZW5yOscLvO2/GobZGJlkp1v9MExq/yUiIiJyRucduvPy8khOTsbtdtOiRQvsdvtpyxiGwXvvvcdzzz3Hnj17MAxDb85ERGoIwzDYnJrPrOR09mZ723/FBFsY3iqGfo3U/ktERESkLMp9I7XMzEzuuOMO6tWrxyWXXEK3bt2Ij4/nxhtv5PDhw77lVq5cyUUXXcQf/vAHdu/eDcCwYcNYv369/6o/h8TEREwmU6lf/fv3L9e6PvroI7p37054eDh2u51rrrmGH3/8sXIKFxEJsB2Zhfx9wxFe/vEoe7MdhFnNjGxtZ3LvJlzRRO2/RERERMqqXEe6XS4XV155JT/88AOGYfimG4bBwoUL2b59Oz/++CNvvPEGEyZMwOPxYLFYGDlyJI8++igdOnTw+w6cS3R0NH/+859Pm56YmFjmdfz973/niSeeoHnz5vzxj38kOzubWbNmcdlll7F8+XJ69erlv4JFRALoUK6DOcnpfHcsDwCrCQY3i+K6FjFEBulu5CIiIiLlVa7Q/d5777FhwwYALr/8coYMGYJhGCxevJivvvqKX3/9lXvuuYf33nsPk8nE7bffzlNPPUXLli0rpfiyiImJYeLEief9/OTkZCZOnEibNm347rvviI6OBmDcuHH06NGDu+66i61bt2I2V7j7mohIwKQXuJi/K4OVB7PxGGAC+jSK4KZWduJCq+T2HyIiIiK1UrneSc2dOxeTycRdd93Fv//9b9/0hx9+mLvvvpupU6fy/vvvY7fb+fjjj+nXr5/fC65q06ZNw+Vy8fjjj/sCN3j7k48ePZrp06ezZs0a+vbtG8AqRUTOT67TzWd7MvlybxYOj/cMpkviwxjZ2k7TyKAAVyciIiJS85UrdG/ZsgWAJ5544rR5Tz75JFOnTgXgpZdeqjaBu7CwkOnTp3Po0CGioqLo1q0bl156aZmfv3LlSgAGDRp02rzBgwczffp0Vq1apdAtIjWKw+1h6f5sFu7OIKeo/VebmGBGJcXSzh4S4OpEREREao9yhe7U1FTCwsJo0qTJafOaNm1KWFgY+fn5XHfddX4rsKKOHDnC2LFjS0zr1q0bM2fOpFWrVud8fnJyMhERESQkJJw2LykpybeMiEhN4DEMVh/KYd7OdFIL3AA0Dve2/+oSr/ZfIiIiIv5WrtDtcDiIjY094/zIyEjy8/Np0KBBhQvzh7Fjx9KnTx8uvPBCIiIi2L59O5MmTeKDDz7giiuuYMuWLURGRp51HZmZmdSvX7/UeVFRUb5lzmTSpElMmjSpzDUXFhaWeOxyuXA6nWV+flUorqe61SW1n8be+TMMg02pBczdlcnBXG+v7dhgCze0iKJ3QhhmkwmXyxXgKqs3jT8JJI0/CRSNPQmkmjD+bDbbOZep1XfHefrpp0s87ty5M++//z4AH3zwAe+++y7jx4+v1BqysrI4ePDgeT9/3bp1Zw31gbR06dJAlyB1lMZe+Rw3h7HZ2pAUSzgAQYaLC1zHaJ2fSs5Ggy8DXF9No/EngaTxJ4GisSeBVJ3H37Bhw865TK0O3Wdyzz338MEHH7B27dpzhu7o6Ogzht6srCzfMmcSFRVF48aNy1xbYWEhKSkpvsc9e/asdi3JnE4nS5cu5corryzTJzsi/qKxVz4Hc53M3ZXJxpQCAGxmGNQkkqubRRJuSwxscTWQxp8EksafBIrGngRSbRl/5Q7dR48exWI5e6/Ws803VYNTGOPi4gDIzc0957JJSUmsW7eOI0eOnHZdd/G13MXXdpdm/Pjx5TqavmbNGvr06eN7bLVaq+0As9ls1bY2qd009s4utcDFvB3pfH0oBwNv+6/+jSMZ3iqG2JA6+VmrX2n8SSBp/EmgaOxJINX08Vfud1+GYVRGHVVq/fr1ACQmJp5z2X79+rFu3TqWLFnC7bffXmLe4sWLfcuIiARajtPNwl2ZLNmfhbOo/Ve3+mHcnGSncbjaf4mIiIgEQrlC96nXSFdnv/32G82aNSMsLOy06RMmTADglltu8U3PzMzk8OHDREdH07BhQ9/0sWPH8uqrr/L3v/+dYcOG+U4l37RpEzNnzuSCCy6gd+/eVbBHIiKlK3R7WLwvi093Z5Ln8rb/amcPYXSSnaQYtf8SERERCaRaG7pnzZrFpEmT6Nu3L82bNyc8PJzt27ezaNEinE4njz76aIne2p988gljx47ljjvuYPr06b7pbdq0YeLEiTzxxBN06tSJ4cOHk52dzaxZswB49913MZvNVb17IiK4PQarDmUzf2cG6YXe9l9NI2yMSoqlc1yo2n+JiIiIVAO19uK+AQMG8Ouvv7Jx40ZWr15NXl4ecXFxDB06lHHjxjFo0KAyr+vxxx8nMTGR1157jbfeeougoCD69OnDc889xyWXXFKJeyEicjrDMPj+WB6zk9M5nOdtoREXYmVE6xh6NYzArLAtIiIiUm3U2tDdr1+/cl1rPWbMGMaMGXPG+b/73e/43e9+54fKRETO369p+cxMTmdHZiEAETYzN7SMYWDTKGxmhW0RERGR6qbWhm4RkdpkX7aDWclpbErJByDYbOKqxGiuaR5NmE2XuIiIiIhUVwrdIiLV2PF8J3N3ZLD2sLf9l8UEAxpHcmOrGGKC9RIuIiIiUt3pHZuISDWU5XCzYFcGy/Zn4Srq1NijQTgjWttpGF5z+1SKiIiI1DUK3SIi1UiBy8MX+zL53+5M8t3etN0hNoTRSbG0jA4OcHUiIiIiUl4K3SIi1YDLY7DiYDYf78wg0+Ft/5UYGcToNrF0rBca4OpERERE5HwpdIuIBJDHMFh/NJc5O9I5mucCoEGolRGt7fRICFf7LxEREZEaTqFbRCRAtqbmMzM5jd1ZDgCigszc2NLO5U0isar9l4iIiEitoNAtIlLFdmcVMis5jS2pBQCEWExckxjN0ObRhFjV/ktERESkNlHoFhGpIkfznMzZkc66I7mAt/3XwKZRXN8ihuhgS4CrExEREZHKoNAtIlLJMgvdfLwrna8OZOM2wARc1jCcEa3s1A9T+y8RERGR2kyhW0SkkuS5PCzak8nnezMpLGr/1aleKCOT7CRGqf2XiIiISF2g0C0i4mdOj8Hy/Vl8siuDbKcHgFZRwYxqY6dDrNp/iYiIiNQlCt0iIn7iMQy+OZzL3B3pHC/wtv9qGGZjZJKdbvXDMKn9l4iIiEido9AtIlJBhmGwOTWfWcnp7M32tv+KCbYwvFUM/Rqp/ZeIiIhIXabQLSJSATsyC5m1PY1f0r3tv8KsZq5NjGZI8yiCLWr/JSIiIlLXKXSLiJyHQ7kO5iSn892xPACsJhjcLIrrWsQQGaT2XyIiIiLipdAtIlIO6QUu5u/KYOXBbDxF7b/6NIrgplZ24kL1kioiIiIiJekdoohIGeQ63Xy2J5Mv92bh8Hjbf10SH8bI1naaRgYFuDoRERERqa4UukVEzsLh9rB0fzYLd2eQU9T+q01MMKOSYmlnDwlwdSIiIiJS3Sl0i4iUwmMYrD6Uw7yd6aQWuAFoHG5jVJKdS+LV/ktEREREykahW0TkJIZh8OPxfGYnp3Eg1wlAbLCFm1rb6dsoArPCtoiIiIiUg0K3iEiRbekFzExOY3tGIQDhVjPDWsYwqGkkQWr/JSIiIiLnQaFbROq8AzkOZien88Nxb/svm9nEVc2juDYxmnCb2n+JiIiIyPlT6BaROiu1wMW8Hel8fSgHA2/7r/6NIxneKobYEL08ioiIiEjF6V2liNQ5OU43C3dlsmR/Fs6i9l/d6odxc5KdxuFq/yUiIiIi/qPQLSJ1RqHbw+J9WXy6O5M8l7f9Vzt7CKOT7CTFqP2XiIiIiPifQreI1Hpuj8GqQ9nM35lBeqG3/VfTCBujkmLpHBeq9l8iIiIiUmkUukWk1jIMg++P5TE7OZ3Ded72X3EhVka0jqFXQ7X/EhEREZHKp9AtIrXSr2n5zExOZ0emt/1XhM3MDS1jGNg0CptZYVtEREREqoZCt4jUKvuyHcxKTmNTSj4AwWYTVyVGc03zaMJs6rUtIiIiIlVLoVtEaoXj+U7m7shg7WFv+y+LCQY0juTGVjHEBOulTkREREQCQ+9ERaRGy3K4WbArg2X7s3B5u3/RIyGcm1vbSQizBbY4EREREanzFLpFpEYqcHn4Yl8m/9udSb7bm7Y7xIYwuk0sLaOCA1ydiIiIiIiXQreI1CgeYPnBHBbuySbT4W3/lRgZxOg2sXSsFxrY4kRERERETqHQLSI1gscwWH80jy+C25KzPQOABqFWRrS20yMhXO2/RERERKRaUugWkWpva2o+M5PT2J3lAHMwUTYzN7ayc3mTSKxq/yUiIiIi1ZhCt4hUW7uzCpmVnMaW1AIAQiwmWhcc5oE+lxAZquu2RURERKT6U+gWkWrnaJ6TOTvSWXckF/C2/xrYNIprmoazZtlPhFjVb1tEREREagaFbhGpNjIL3Xy8K52vDmTjNsAEXNYwnBGt7NQPs+F0OgNdooiIiIhIuSh0i0jA5bk8LNqTyed7Myksav/VqV4oI5PsJKr9l4iIiIjUYArdIhIwTo/B8v1ZfLIrg2ynB4BWUcGMamOnQ6zaf4mIiIhIzafQLSJVzmMYfHM4l7k70jle4AKgYZiNkUl2utUPw6T2XyIiIiJSSyh0i0iVMQyDzan5zEpOZ2+2A4CYYAvDW8XQr5Haf4mIiIhI7aPQLSJVYkdmIbO2p/FLurf9V5jVzLWJ0QxpHkWwRXcjFxEREZHaSaFbRCrVoVwHc5LT+e5YHgA2s4lBTSO5rkUMkUGWAFcnIiIiIlK5FLpFpFKkF7iYvyuDlQez8RS1/+rTKIKbWtmJC9VLj4iIiIjUDXrnKyJ+let089meTL7cm4XD423/dUl8GCNb22kaGRTg6kREREREqpZCt4j4hcPtYen+bBbuziCnqP1Xm5hgRiXF0s4eEuDqREREREQCQ6FbRCrEYxisPpTDvJ3ppBa4AWgcbmNUkp1L4tX+S0RERETqNoVuETkvhmHw4/F8ZiencSDXCUBssIWbWtvp2ygCs8K2iIiIiAi1sk/PwYMHee211xg0aBDNmjUjKCiIhIQEhg8fzvr168u8npUrV2Iymc74NX369MrbCZFqbFt6Ac98f5h/bjrKgVwn4VYzt7SJZVLvJvRvHKnALSIiIiJSpFYe6X7jjTd4+eWXadWqFYMGDSI+Pp7k5GQWLFjAggULmDFjBiNHjizz+vr160f//v1Pm965c2f/FS1SAxzIcTA7OZ0fjp9o/3VV8yiuTYwm3Kb2XyIiIiIip6qVobt79+6sXLmSfv36lZi+evVqrrjiCu69916uv/56goODy7S+/v37M3HixEqoVKRmSC1wMW9HOl8fysHA2/6rf+NIhreKITakVr6MiIiIiIj4Ra18t3zjjTeWOr1Pnz4MGDCAJUuWsGXLFrp27VrFlYnULDlONwt3ZbJkfxbOovZf3eqHcXOSncbhav8lIiIiInIutTJ0n43NZgPAai37ricnJ/Paa6+Rn59PkyZNuPzyy2ncuHFllSgScIVuD4v3ZfHp7kzyXN72XxfYQxiVZCcpRu2/RERERETKqk6F7n379rFs2TIaNmxIx44dy/y8GTNmMGPGDN9jq9XKAw88wD/+8Q8slrNfxzpp0iQmTZpU5m0VFhaWeOxyuXA6nWV+flUorqe61SUV5/YYrD6Syye7s8hweMN2k3AbN7eK4qLYEEwmU0D/3TX2JJA0/iSQNP4kUDT2JJBqwvgrPqh7NibDMIwqqCXgnE4nAwcO5Ouvv+b999/ntttuO+dzfv75Z/73v/9xzTXXkJiYSG5uLuvWreORRx7ht99+Y/z48fzzn/886zomTpzIM888c951v/DCC7Rv3/68ny9SFgZw0BzFZlsC2Wbvkewwj4OOriM0c2fUzjYHIiIiIiIVNGzYsHMuUydCt8fj4bbbbmPGjBncddddvPPOOxVa35EjR7joootIT0/n4MGD1K9f/4zLns+R7pSUFN/jFStW0KtXrwrV629Op5OlS5dy5ZVXlumTHanefksvZM6uTHZmOQCIsJkZ1jySAY0jsJmrV+svjT0JJI0/CSSNPwkUjT0JpJow/spSV60/vdzj8fD73/+eGTNmcOutt/Lvf/+7wutMSEhg2LBhTJ06lfXr13Pttdeecdnx48czfvz4Mq97zZo19OnTx/fYarVW6wFWXWuTc9uX7WBWchqbUvIBCDabGJoYzdWJ0YRZq/exbY09CSSNPwkkjT8JFI09CaSaPv5qdej2eDyMHTuW999/n9GjRzN9+nTMZv+Eibi4OAByc3P9sj6RqnI838ncHRmsPext/2UxwYDGkdzYKoaY4Fr9kiAiIiIiUuVq7TvskwP3yJEj+eCDD85507PyWL9+PQCJiYl+W6dIZcpyuFmwK4Nl+7NwFV1U0iMhnJtb20kIq7mfHIqIiIiIVGe1MnQXn1L+/vvvM2LECD788MOzBu6UlBRSUlKIi4vzHcEG+OGHH+jSpctpy7/++uusWLGCpKQkunXrVin7IOIvBS4Pi/Zm8vmeTPLd3rTdITaE0W1iaRkVHODqRERERERqt1oZup999lnee+89IiIiaNOmDc8///xpy1x//fV07twZgClTpvDMM8/w9NNPM3HiRN8yw4cPx2az0bVrV5o0aUJubi7ffvstGzduJCYm5pxhXiSQXB6DFQey+XhXBpkONwCJkUGMbhNLx3qhAa5ORERERKRuqJWhe8+ePQDk5OTw97//vdRlEhMTfaH7TO69914WL17M119/TWpqKmazmebNm/PnP/+Zhx56iCZNmvi5cpGK8xgG64/mMmdHOkfzXAA0CLUyorWdHgnhmE3V647kIiIiIiK1Wa0M3dOnT2f69OllXn7ixIkljnAXmzBhAhMmTPBfYSKVbEtqPrOS09hd1P4rKsjMjS3tXN4kEms1a/8lIiIiIlIX1MrQLVLX7M4qZFZyGltSCwAIsZi4JjGaoc2jCanm7b9ERERERGozhW6RGuxonpM5O9JZd8Tbus5igoFNo7i+RQzRwbrfgIiIiIhIoCl0i9RAmYVuPt6VzlcHsnEbYAJ6NQznplZ26qv9l4iIiIhItaHQLVKD5Lk8LNqTyed7Myksav/VqV4oI5PsJKr9l4iIiIhItaPQLVIDOD0Gy/dn8cmuDLKdHgBaRQUzqo2dDrFq/yUiIiIiUl0pdItUYx7D4JvDuczdkc7xAm/7r4ZhNkYm2elWPwyT2n+JiIiIiFRrCt0i1ZBhGGxOzWdWcjp7s73tv2KCLQxvFUP/RpFY1P5LRERERKRGUOgWqWZ2ZBYya3sav6R723+FWc1cmxjNkOZRBFvU/ktEREREpCZR6BapQh7D4Lf0AjIK3cQEW2hnD8FcdIr4oVwHc5LT+e5YHgA2s4lBTSO5rkUMkUFq/yUiIiIiUhMpdItUke+O5vLRtjTftdkA8SFWrm8Zzc4sBysPZuMpav/Vp1EEN7WyExeq/6IiIiIiIjWZ3tGLVIHvjuby+k/HuDg+jPsviqdpRBDbMwqY9lsq7/6S6lvukvgwRra20zQyKIDVioiIiIiIvyh0i1Qyj2Ew/dcUmkcEcWmDMA7mOFi8L4sfjudS6PYuYwEe7ZpAe7X/EhERERGpVRS6RSrZb+kFZDg8ZDgcvLU1pdRl3FVck4iIiIiIVA2FbpFKll50DXeoBfJPSteto4JoHhWExwMrDuWQUajoLSIiIiJS2yh0i1Si7RkFfLo7EygZuAF2ZDnYkeXwPY4J1h3KRURERERqG4VukUpwMMfB7B3pbChq/wUQZTNzU+sYQqwnem0bBnyxJ4sMp4t29pBAlCoiIiIiIpVIoVvEj1ILXMzfmc6qgzkYeNt/9W8cQcvoYP77SyqbUgq4rkU0TSOC2J/j4NPdmezNcfBgp/q+ft0iIiIiIlJ7KHSL+EGO081nuzP5cl8WTo8BQNf63vZfjSO87b8ibRY+2pbGxO8O+54XH2rlwU716d4gPCB1i4iIiIhI5VLoFqkAh9vDkv3ZLNyVQa7LA0DbmGBGt4mlTUzJ08W7Nwina/0w793MC93EBFtoZw/REW4RERERkVpMoVvkPHgMg68P5TBvRzppRXcdbxJuY1SbWC6OC8V0hiBtNpnUi1tEREREpA5R6BYpB8Mw+PF4HrOT0zmQ6wSgXoiFEa3s9G4UoaPWIiIiIiJSgkK3SBltSy9gZnIa2zMKAQi3mrm+ZQxXNo0kyGI+x7NFRERERKQuUugWOYcDOQ5mJ6fzw3Fv+68gs4khzaO4NjGacJt6a4uIiIiIyJkpdIucQentvyIZ3iqG2BD91xERERERkXNTchA5RWntv7rVD+Pmk9p/iYiIiIiIlIVCt0gRh9vD4n1ZLNydSV5R+692McGMKqX9l4iIiIiISFkodEud5/YYrD5csv1X0wgbo5Ji6XyW9l8iIiIiIiLnotAtdZZhGPxQ1P7rYFH7r7gQCze1ttO7odp/iYiIiIhIxSl0S510avuvCJuZYS3U/ktERERERPxLoVvqFLX/EhERERGRqqTQLXVCaoGLeTvS+fqQt/2X2VTU/qtlDHa1/xIRERERkUqitCG1Wo7Tzae7M1l8avuvJDuNw9X+S0REREREKpdCt9RKDreHL/dl8enJ7b/sIYxOspOk9l8iIiIiIlJFFLqlVnF7DL4+lMP8nWr/JSIiIiJS0zh++QlX8q8AuNwuYjdtIt+djdPija7WpAsIat8pkCWWm0K31AqGYbDheB5zTmn/NaK1nV5q/yUiIiIiUiNkPvdXnN+t9j1uBeR8dGK+rXsf4mcurfrCKkChW2q839ILmLk9jeTME+2/rm8Zw8Amav8lIiIiIlKTRD/5Kq7kX/FkZ5L19IMARDw1CWtMLOA90l3TKHRLjbU/28HsHen8eFL7r6uaR3FtYgxhNoVtEREREZGaJqh9J4Lad8KVcswXuoMHDyM4oXGAKzt/Ct1S46Tku5i3M53VJ7X/GtA4khvV/ktERERERKoZJRSpMXKcbhbuymTJ/hPtv7o3COPm1nYaqf2XiIiIiEjt4XH7fnT8uJ6gwcMwWSwBLOj8KXRLtVfo9rD4lPZfFxS1/2qt9l8iIiIiIrVK/uIFZDz7kO9x9gO3kNekOVGPvUzo4OsDV9h5UuiWaqu4/de8nemkF7X/ahYRxKgkO53U/ktEREREpNbJX7yA9PtGY+t9Oc4jBwGIensehXOmkX7faPjXzBoXvBW6pdoxDIMNx/KYvSOdQ772X1Zubm3nsobhav8lIiIiIhJghmGA04nhdoHLBa4TPxsuJ7jcRY+d3mluV4nlDZcL3EXfi5bxOB1kvzABa9sLCb60P87VywGwtGhD7L/nkvbHEWS9+AghA6+tUaeaK3RLtfJbegEztqex46T2Xze0jGFg0yhsZoVtEREREam+KiOIFi/vnefGcDpLLuP7+eTne5+L23Viebf7lG05T5rvLjnNVXKbJ34+ad0eT6X9Hj3pqeT8thnwvv93HFhOSItWRP7xYVJG9Mfx/RqCe/SrtO37m0K3VAv7sx3MSk5jY0o+AMFmE1clRnNN82i1/xIRERGpwWpMEC3+Xk2DaI1hs2GyWMFqBeuJn01WK1iKvlttRdNsRdMsYLXhSUvBlbEZ89CmeGL3w0femyfnJo8j7/BThDQdAQ08uI8dCfBOlo9CtwTUGdt/tYrBHqzhKSIiIrVTTQmiHoeDNkePkDHzDXC7FETP17mCqM0bPksLoifCqjeoepcv+m6xlli397mWEz9bi5bxrcdyhm0VL2Mpmmc7rTbvMtaS+3FqbWZzhe67VPjtKlJX98dTf5d3wt0n5hmFKeTveAtuAEv9hAr+g1QtpRoJiGyHm093Z7Bkf7av/delDcK5ubWdhuG2AFcnIiIigVCtg2jxMnXwiGg04KyMFZcWRG0277W6CqI1kmEYGB4XGG4wPBiGu+hn90k/e0489hTNw+P9uVU4bDRBbjgh7W+jYO9bAIQmPUNQfCKZi/8E4TnYuvQM8J6Wj0K3VKlCt4cv92bx6Z4M8l3esN3eHsKoNrG0jg4OcHUiIiLVj2EYGA4HZkchnpwsPBDQIFoikNbhIFppfGHxpHAYwCDqxsSmLVu5uFs3LEHBNTKIGobhC3onwp/nlCB4hpDocQOnhsRCPOT7AqNvnsMNhZ5T1unGOG3bJ9ZbIniWFkpLWcepy5bYnqcowBb/fK79K+v2ivf1lJpPWxaj4v9gYQA5FCS/BUHeSabUCAqmL4Rt+fB7N87UbwhO6F/xbVURhW7xK49h8Ft6ARmFbmKCLbSzh2A2mXB7DFYdymb+zgxf+6/mkd72XxfVU/svEREpn2pxRPS0bVZuEO0CpAb21x441SyI+uuIKBYzmE2YLGYMiwkwMJmM08LSySHxbIHrtJDoOd/A5fAt73E5CPYcwdXkVwyzqfSQ6ChjgC1te8X7WnSk83xD4mnLnhQSMfRhTvVhApMZTBZMJgsUf5ktmDBjeBwYziww1YOcdIj1/tvl/X0ClpBWxDwynYxjt+DOOxzg/SgfhW7xm++O5vLRtjSOF7h80+JDrFzaIIwfjudzOM/pmzYiyc5lCWr/JSLiTwELokVhMhBBtE6rpCCKxQI2KyaLGWyWoiBpBqsZrBZv8LSYwGrxhUWT1eK9MYvVXCJIen/GO89iArP3scliwjCZMFnwzjeZwAyG2eQNnaaTppuMMoTEU0LpyUflSgTPk5/nwFPegHdy2MTjPbJ5tqOOp9R2akisKZoAeZsDXUUl8wVAc4kwaCqaVvLxiZBY/HPJEFlyHd55payjtO2Zi/5TnPy4lHWcWts5ay5eD+ZT1nmG/Ttjzadsz1z0M+ZSfg+l/T7P/t6/8MhKUhcPIO6q/0FBOClfXQRA+ONvEzX0Dpyp38EXYAlrWOlDwp8UusUvvjuay+s/HePi+DDuvyiephFBrD6UzewdGfxvbxag9l8iEhj+CqKuwgLsP31HgZGHE0NBtMqdFMTMgC+snfTdBARZvcHQZvMGRosFgooCpNWCyWYpOpJpLjraaD4RIK0WDLMZU3FwtJjB6g2KJovpxLTiQGnGGziLA6UJb6i0FNdlOhE4i+szG0UB0zgxzWR4989cdFqmyTgxDQ+GycAwPKSkHCcuLtYbSn2nu5Z+9NP7+MTpr56zHCk9LQyW858FV9GX+F+J0FPG0HaWkAjmEgGsLCHRY5g4cPAQTZsmYrbYzh4SzWWprYyhtIIhscR6Ttnv07enTjnVRVD9PphCG5KxbhwhCTf7phvxR8nfM5OcnydhCm1EUP0+Aayy/Gp96P7+++95+umn+eabb3A6nXTs2JHx48dz8803n/vJRQoLC3n55Zf54IMP2L9/P7GxsVxzzTU8//zz1K9fvxKrrxk8hsFH29K4OD6M8Z3rcyDHyRubj/naf5mBEKuZSb2bEGGzBLbYAPM4HeStfhNX2i6ssS0J6zMOsy0o0GVJHVS1R0RPvSFRzQ2irYHskr/Jk8IUp/9c6rRSnnPW5fEGMBvea9vOuewp2zHjDaFm84mjkEVHLU1m04mjk0XB0WQu/hnfUUmKl/P9fNL2TqujlDB5cog0AXjAZGAUhUp8371fhu900BPhsuzXCTpO/Rcq8b1KnMjLfhUNOI/5d53nx1QycJ10lOucAeiMgeuUI2gnB64zhMQyBa5Tt3fyekqp+Wwh8azbM595/862jlIDbHFtpupx8y2n08meRYtof+lQbDbd7FYql8lsweQMxZW/kZz0jb7pedseI2+b92eztWXRhz01R60O3StWrGDw4MGEhIQwatQoIiMjmT9/PiNHjmT//v089NBD51yHx+Nh2LBhLF68mB49ejB8+HCSk5OZOnUqy5cv59tvvyU+Pr4K9qZ6yMk4zrQvZrIvJJEfF85lUHg+UZeM4HiBi4RQC+NX7+dYgQvvuyoPjUJtxIfZ+Cm1gH3ZDtrHhgZ6FwImc+EEcvdPgsiiwwG5kPX2w4Q3HU/0sJcDW5wAVRBEz3pnXP8GUcPl8C5juMHt8N5J1ON9Dh4X3tBD6WHwfMJjmYLjGbZzpuUteP9KVbS20pYzUXSqKyeFyOLHpS3vXZ9hMjD5HhcHyJqg9KOXpQXRSg+nlZaCz3Cd4NlCzWkh8UxH0M5++ua5j8qVMXCdJSR6PPDT5i106nQxVltw+UPiyafCniMklrp/JZatMQNfRGog09J4SN5/5vlJ8fC7KizID2pt6Ha5XNx1112YzWa+/vprOnfuDMBTTz1F9+7deeyxx7jpppto3rz5Wdfz3nvvsXjxYkaPHs1HH33k+0Pz73//m3vvvZcnnniCt99+u7J3p1r4+9z3+DmqD9S71jctGTBvPAzmILakFxZNLf5jbOZQvptD+d43exmF5TxlrRbJXDiB3PRXMDsTiGz1PMEdr6Zwy+dkf/8EuemvwEKqbfA2PJ6TwmPFgqjhLCwKoIXeIOhygsuB4XZ6v1yF4HaC24nhcnhvqOIuWsbjwuMqpPWhg2R8NxWz4fIGSbcLwyjaluECw3UibHrcvrYV3mv6XEWnWnq8yxke4ORr6zzlC48moxxBs/j7WcKjidKPZJ4rQJZ2tFTKoPyp77yiRhlC2xnD0TmPypXxmrvisFnadYKnhMSzBa4zXidYtN6ynQJajpB40n6fOwTX7iDodDpJ/W0RIS10tFFEajf7397GlfwrhuGmMOcX9uz8icRWnQiOaI/JZMGadEGgSyy3Whu6v/rqK3bu3MnYsWN9gRsgOjqaxx57jDFjxvDee+/x1FNPnXU97777LgAvvvhiiT/o99xzD//4xz/46KOPeO211wgNrd1HcH2BG4gr3EP3Q1+RHt2QdfYr8ZhO/PGPKTxMy1ATMXGNcafuwXl0PVlhYWwNG0pMcM05DaS4tYThdhSFwkJvCHQ5MNwO78/uk392esOkx+l9jttZNN+Fx5lH7qFXoTCS0Pb34ck9SN43b4LHRXDiLeTv/Te5+a/inpmCCQM8RaHRUxQqPc4T4fHkAOlxnX7nz9Ju5HLydX/Fp28aJ53CeerpnSddR1jiNNHSTiEtc9Dk7EHQhPfVqAyvSPYWldQrtM455Vq2MoWaM4fE0k8BLe0o2XmGxDKdAlrG7ZU7JHrX4XJ7WLFyNQMuvwKbLYRSj3Ketj19AiIiIlIeQe07EdS+k/dnp5P9ixbRcWjN/sCx1obulStXAjBo0KDT5g0ePBiAVatWnXUdBQUFrF+/nrZt2552RNxkMnHllVfy9ttvs2HDBvr0qVkX85dHTsZx9hntaLzvFxJzN3J1+hbWmJpy2NSQxjneiyuyouLJi4rmqfTpBGdb4Ig3ILo8Tt4OHkCscx/15o8nFc+J4Gic9N3jpviIo+8un5x0d1CjqOeg76toGZPnpGsCi49UngiMBgaYisPjyTeqMU46elh85PGUm/T4Uy6Qn03ud0+WPt8FBWH/LTnNhPf02przWUXFGQBmME49Z9mMCTMGJlwuDzZr0InQ5QuP5pOmnRzSzGCynnhstmIyW4uCnNUbusxWTGabNziZrZgstpLfy3Od4HmExNIC3mmngJbrVNhStlfiKKdODz0fhtOJw7IdS3gzLDX4D7+IiIhUrVobupOTkwFISko6bV5CQgIRERG+Zc5k586deDyeUtdx8rqTk5PPGLonTZrEpEmTylx3YWFhicculwunM7DH9d77chYdjx5kX6OuJMd14bXmXU5bplnuepJ+Xc9GVxotHBsINTLJN0VzwNqRNikrucL2f7hjNp/hqsIa5tR7/hiAx1R04xzTSY+LvqxucHug2VnWeQRID8XkjvKGqOKjhqaiC1tNRad/Fv3sDYKn/lzU6qU4ZFmsYLaCqTg8WsBi8wZOsxWTJci7fHG4tNhOfLfawGzDZA0C37Rgb5sZS5B3uRJHOU2nH1089VTWsxzRLGsQdDqdLF26lCuvvLJGf9rpL6eeHH3Wk6U9J/9Qm+9wXXmKX4sD/ZosdZPGnwSKxp4EUk0Yf2V5T1prQ3dmZibgPZ28NFFRUb5lKrKOk5crTVZWFgcPHjxnvWeybt26c9ZZ2Y5aYtnZbgiG6czD5Vj4BeRHxzMu7RbfNBsptGeF98ERcB0PxeWKBsOMUXT00jC85x8bWDCKjmoaRX1gDMwYJjOGYfF+Lwqc3mW9Qa14uuH72er9bvKGT4/JUjTfimEu+tlsxTBZ8RQvYy5e1uqdVzy/6LthLv7ZhmH29i81TGYwl+1weIO9n9HM8h8Kfq6Hyxxx2nyrJ4eQ+qnsM9/C0RbXlrKGSlCcu8r9+lU9+sIsXbo00CVIHabxJ4Gk8SeBorEngVSdx9+wYcPOuUytDd3VRVRUFI0bNy7z8oWFhaSkpPge9+zZk169elVGaWV2YP6/CTu4gOMxrXCZS792PS53F22PfUN6VnsswdEUYiUYF9GeHIyCNIg6SHSn5wnr/0AVVx94HudAUv/7HqEJNmLH/YrZcuK/ncftIu3NlhhBNi7+/etqH3YOOtItgaTxJ4Gk8SeBorEngVRbxl+tDd3FR6fPdJQ4KysLu91e4XWcvFxpxo8fz/jx489Zb7E1a9aUOFXdarUGfIDdMWQUd6/PBqBd9loevno4S5YsZejQoRQW5vHHtYc5HtqWI/aOXD+gC0Gh4b7netwujv1fUzw2G5H978dcg/+znDebjfCm48lNf4X0t1oS2fVZgi+8msKtn5O94SmM2COE2/9GcFj4udclgPc0nkD/v5C6S+NPAknjTwJFY08CqaaPv1p7W9WTr7c+1ZEjR8jJyTnjtdrFWrZsidlsPuO132e7brw2iYiJp0PWagB+i+zF35atJ+vwBv4z703+uPYIHrxHZ6/LeoG0f7cmd/W7uNIPkbv6XW/gth8hvOlf6vRR3OhhLxNu/xseWwqZu+7m2KeNydx1Nx5bKuH2v1XbdmEiIiIiIlIxtTZ09+vXD4AlS5acNm/x4sUlljmT0NBQunfvzrZt29i7d2+JeYZhsHTpUsLDw+nataufqq6+Hh9xhy94pwYn8kXL3/N1vevwmIKwGfnc7VhCj9BOCpVnET3sZRLuySWq6WTCwh8gqulkEu7J0e9GRERERKQWq7Wnl19xxRW0bNmSGTNm8Kc//cnXqzszM5MXXniBoKAgbr/9dt/yhw8fJjMzk4YNG5Y4Xfzuu+/m22+/5dFHH+Wjjz7y3V357bffZteuXdx99921vkd3scdH3EFOxnGmfTGTfSGJhLlzGBSez6VX3Io1qAMAkc7nyFv9Jq60XVhjWxLWZ1ydPsJ9KrMtiIjL/xzoMkREREREpIrU2tBttVqZOnUqgwcPpm/fvowaNYrIyEjmz5/P3r17efXVV0lMTPQt/+ijj/Lee+8xbdo0xowZ45t+xx13MHv2bGbOnMnu3bvp168fO3bs4OOPP6ZFixY8//zzVb9zARQRE88fb7qXRYsWMfSaEaddW6FQKSIiIiIickKtPb0cYMCAAaxZs4ZevXoxe/Zs3nrrLRo0aMCsWbN46KGHyrQOs9nMwoULmThxIsePH2fy5MmsXbuWP/zhD6xbt474+PhK3gsRERERERGpqWrtke5i3bt354svvjjnctOnT2f69OmlzgsODubpp5/m6aef9nN1IiIiIiIiUpvV6iPdIiIiIiIiIoGk0C0iIiIiIiJSSRS6RURERERERCqJQreIiIiIiIhIJVHoFhEREREREakkCt0iIiIiIiIilUShW0RERERERKSSKHSLiIiIiIiIVBKFbhEREREREZFKotAtIiIiIiIiUkkUukVEREREREQqiUK3iIiIiIiISCWxBroAObvc3FyysrICXUYJTqeTvLw8srKysNlsgS5H6hCNPQkkjT8JJI0/CRSNPQmkmjL+IiMjMZlMZ5yv0F3NDRkyJNAliIiIiIiIyBlkZmYSFRV1xvkK3dXcl19+Sc+ePQNdRgnt2rXj8OHDNGzYkN9++y3Q5UgdorEngaTxJ4Gk8SeBorEngVRTxl9kZORZ5yt0VzMdO3Zk9erVJR6f7VOTQDCbzb7v1a02qd009iSQNP4kkDT+JFA09iSQasv4U+iuZqKjo+ndu3egyxARERERERE/0N3LRURERERERCqJQreIiIiIiIhIJVHoFhEREREREakkCt0iIiIiIiIilUShW0RERERERKSSKHSLiIiIiIiIVBKFbhEREREREZFKotAtIiIiIiIiUkkUukVEREREREQqiUK3iIiIiIiISCWxBroAqXnGjx9PVlYWUVFRgS5F6hiNPQkkjT8JJI0/CRSNPQmk2jL+TIZhGIEuQkRERERERKQ20unlIiIiIiIiIpVEoVtERERERESkkih0i4iIiIiIiFQShW4B4Pvvv2fo0KHExMQQHh5Ojx49mDNnTrnWUVhYyLPPPktSUhIhISE0atSIu+++m2PHjlVS1VIbVGTsGYbBF198wb333stFF11EdHQ0YWFhdOrUiRdeeIGCgoJKrl5qOn+89p0sPT2dxo0bYzKZGDJkiB8rldrIX+Pv2LFj/OUvf/H9/a1Xrx49e/bkrbfeqoSqpTbwx9g7dOgQDz74IO3btyc8PJwGDRrQu3dvPvjgA9xudyVVLjXdhx9+yD333EPXrl0JDg7GZDIxffr0cq/H4/Hwxhtv0LFjR0JDQ4mPj2f06NHs2rXL/0X7gW6kJqxYsYLBgwcTEhLCqFGjiIyMZP78+ezdu5dXX32Vhx566Jzr8Hg8DB06lMWLF9OjRw/69etHcnIyn3zyCS1atODbb78lPj6+CvZGapKKjr2CggJCQ0MJDg6mf//+dOzYkYKCAhYvXkxycjLdunVj5cqVhIWFVdEeSU3ij9e+U/3ud79j4cKF5ObmMnjwYL788stKqFxqA3+Nv02bNjFo0CDS09O5+uqrueCCC8jJyeHXX38lKCiIRYsWVfKeSE3jj7G3a9cuLr30UlJTUxk8eDAXXXQRWVlZLFiwgCNHjjBmzBimTZtWBXsjNU1iYiJ79+4lLi6O8PBw9u7dy7Rp0xgzZky51nPXXXcxdepUOnTowNVXX82hQ4eYM2cOERERfPvttyQlJVXODpwvQ+o0p9NptGrVyggODjY2btzom56RkWG0adPGCAoKMvbs2XPO9fz3v/81AGP06NGGx+PxTX/rrbcMwLj77rsro3ypwfwx9hwOh/H8888baWlpp02/9tprDcB45ZVXKqN8qeH89dp3snnz5hmAMWXKFAMwBg8e7Oeqpbbw1/jLzMw0mjVrZsTHxxs//fRTqdsROZm/xt69995rAMZrr71WYnp6errRrFkzAyj3a6jUDUuXLvWNjRdffNEAjGnTppVrHV999ZUBGH379jUKCwt90xctWmQAxqBBg/xZsl/o9PI67quvvmLnzp3ccsstdO7c2Tc9Ojqaxx57DIfDwXvvvXfO9bz77rsAvPjii5hMJt/0e+65h5YtW/LRRx+Rn5/v9/ql5vLH2LPZd06+EQAAGzBJREFUbDz++OPY7fbTpj/66KMArFq1yu+1S83nr9e+YsePH+fee+/ltttu4+qrr66EiqU28df4e/PNN9m3bx8vvfQSF1100WnzrVarP8uWWsBfY6/4FN6hQ4eWmB4TE0Pv3r0BSElJ8V/hUmsMHDiQ5s2bV2gdxbnjueeeIygoyDf9qquuon///ixZsoR9+/ZVaBv+ptBdx61cuRKAQYMGnTZv8ODBwLlDS0FBAevXr6dt27an/ScymUxceeWV5ObmsmHDBv8ULbWCP8be2dhsNkBvOqV0/h5/f/zjH7FYLLz++ut+qU9qN3+Nv9mzZ2MymRg+fDjbtm3jjTfe4JVXXuHTTz/F4XD4tWapHfw19i688EKA0y5fyMjIYO3atSQkJNC+ffsKVitSupUrVxIeHk6vXr1Om+eP95CVQe9G67jk5GSAUq97SEhIICIiwrfMmezcuROPx3PGayeKpycnJ9OnT58KViy1hT/G3tn897//BUp/YyHiz/H34Ycf8vHHH7NgwQLsdjuZmZl+rVVqH3+MP4fDwZYtW4iPj+eNN97g6aefxuPx+Oa3bNmSBQsW0LFjR/8WLzWav177Hn74YT777DP+8pe/8OWXX5a4pjssLIxPPvmE0NBQv9cvkpuby+HDh7nwwguxWCynzT85d1QnOtJdxxW/OYyOji51flRU1DnfQJZlHScvJwL+GXtn8sUXX/D2229zwQUX8Ic//OG8a5Tay1/j79ChQ/zpT39i9OjRDBs2zK81Su3lj/GXlpaG2+0mNTWVZ599lldeeYWjR49y4MABnnzySXbv3s21116rLg5Sgr9e+xo0aMC6desYMmQIX375Ja+88gr//ve/yczM5Pbbb6dTp05+rVukWE3NHQrdIlKrfP/994wcOZLo6Gjmzp1LcHBwoEuSWuzOO+/EZrPxf//3f4EuReqY4qPabrebcePG8dBDD1G/fn0aN27Ms88+y4gRI9i7dy/z5s0LcKVSG+3YsYNevXpx/PhxVq9eTXZ2Nvv37+epp57iueee44orrlDbMJGTKHTXccWfEp3p06CsrKwzfpJUnnWcvJwI+GfsnWrDhg0MGjQIs9nM4sWL6dChQ4XrlNrJH+Pvvffe44svvuBf//oXcXFxfq9Rai9//u0FuO66606bXzxN91ORk/nrb++YMWPYu3cvn332Gb179yYiIoImTZrwyCOP8MADD7Bu3TpmzZrl19pFoObmDoXuOu5s1z0cOXKEnJycc/a5a9myJWaz+YzXTpzt+iGpu/wx9k62YcMGrrzySjweD4sXL6Zbt25+q1VqH3+Mv/9v786jorruOIB/Z2MbEEai6EEcCZoYtZpGFHFDNC5ZTw0q2sRgq9gsRQsxURMtLgStVVzSuguYY0WPsau1EhRN3YrFrZq4VB2NxrUKguzLr39w3gvjzKDoDAb9fs55B7n3vje/+3gO/Oa+e9/hw4cBAMOHD4dGo1G34OBgAEBmZiY0Go3VCsFEgHOuP6PRiMDAQAA1K0bfTSnjk0OoNmdce4WFhdi7dy+ee+45tGjRwqY+MjISwPfvkUTOZDQa0bJlS1gsFrt3U/xQ8w4m3U+4iIgIAMCXX35pU5eZmWnVxhFPT090794dp06dwoULF6zqRARZWVkwGo0IDQ11UtT0OHDGtadQEu6qqips27YNYWFhzguUHkvOuP7Cw8MxduxYmy06OhoA0KpVK4wdOxZvvPGGk6Onxs5Z73/9+/cHAHzzzTc2dUpZmzZtHjRMegw549pTVsZ39EiwGzduAACnd5HLREREoKioCHv37rWpU67jvn37NnRYdXvUDwqnR6uiokKefvppcXd3l8OHD6vl+fn58swzz4ibm5tYLBa1/PLly3LixAnJz8+3Ok5qaqoAkFGjRkl1dbVavmzZMgEg48ePd3VXqJFx1rWXm5srfn5+4u3tLXv27Gmg6Kmxc9b1Z4/FYhEAMnjwYBdETo8DZ11/e/fuFQDSsWNHycvLU8uvXLkigYGBotVq5dSpUy7uDTUmzrr2nn32WQEgq1atsirPy8uT9u3bCwDJyspyZVfoMTBnzhwBIGlpaXbrb9y4ISdOnJAbN25YlWdnZwsA6du3r5SVlanlW7duFQAyaNAgV4b9QJh0k2RnZ4vBYBAfHx+JjY2VhIQEMZvNAkDmz59v1TYmJsbuf46qqioZPHiwAJAePXrI5MmTJSoqSjQajQQHB8v169cbsEfUWDzstXfz5k0xmUwCQIYMGSKJiYk228KFCxu2U9RoOOO9zx4m3XQ/nHX9JSQkCAAJCgqS9957T2JjY6V58+YCQJKTkxuoN9SYOOPa27p1q+j1egEgAwYMkEmTJsnYsWOlWbNmAkCioqIasEfUmKxatUpiYmIkJiZGXnjhBQEgvXr1Ustqf5CTmJgoACQxMdHmOOPGjVM/dPzoo49k9OjR4ubmJk2bNv1BftjIpJtERCQnJ0eGDBkiTZo0EU9PT+nevbts2LDBpl1dv/hLS0tlxowZEhISIm5ubtKiRQsZN26cXL16tQF6QI3Vw1x7SnJT12Y2mxuuM9ToOOO9725Muul+Oev6S0tLk9DQUPHy8hKj0Si9e/eWP/7xjy6OnhozZ1x7Bw4ckOHDh0vLli1Fr9eLt7e3dOvWTT777DOprKxsgF5QY6RcU462mJgYtW1dSXdVVZUsXrxYOnbsKO7u7uLv7y/R0dFy5syZhutMPWhERJx8xzoRERERERERgQupEREREREREbkMk24iIiIiIiIiF2HSTUREREREROQiTLqJiIiIiIiIXIRJNxEREREREZGLMOkmIiIiIiIichEm3UREREREREQuwqSbiIiIiIiIyEWYdBMRERERERG5CJNuIiKiRq5fv37QaDSYMWPGow7lkSouLsb06dPx3HPPwdPTExqNBhqNBkeOHHnUoRERkROtW7cOv/jFLxAaGgp3d3doNBqkp6c79TUsFgtiY2NhNpvh7u6OgIAAREZGYtOmTfU+FpNuIiJ6LM2YMUNNury8vHD58mWHbc+fP6+23bVrV8MFSU4VHR2NpKQknDx5EhqNBgEBAQgICIDBYLiv/ZUPL+7ejEYjQkJCMHLkSGRmZrq4F0REdC/Tpk3DypUrceHCBbRs2dLpx8/KykKnTp2wfv16hIeH44MPPsAbb7yB8vJybN++vd7H0zs9QiIioh+YkpISzJw5EytWrHjUoZCLnDx5Elu2bAEAbNy4ESNGjHjgYxkMBjRt2lT9/ubNmzh37hzOnTuHjRs3Yty4cVi5ciU0Gs1Dx01ERPW3evVqtGvXDmazGXPnzsXUqVOdduxvv/0Ww4YNQ2BgILZv347WrVtb1VdWVtb7mBzpJiKiJ0JqaipOnz79qMMgFzl27BgAwN/f/6ESbgDo2bMnrl69qm6lpaXIzc1Fnz59ANT8sZeamvrQMRMR0YN58cUXYTab77v99evXER8fj7Zt28Ld3R1PPfUUoqKicPz4cZu2ycnJKCgowPLly20SbgDQ6+s/bs2km4iIHmtBQUHo3LkzKisr8fHHHz/qcMhFiouLAQDe3t5OP7ZOp0PXrl3xl7/8Bf7+/gCANWvWOP11iIjI+c6ePYuuXbti0aJFCAkJQVxcHF5++WVs27YNPXr0QE5OjtpWRLBp0yb4+/ujf//+OHjwIFJSUjB//nxs374d1dXVDxQDk24iInqsabVazJkzBwCwefNmHDhwoF77157vff78eYft2rRpY3chl7v3v3DhAmJjY9G6dWt4eHggJCQE06ZNQ1FRkbrP8ePH8dZbbyEoKAgeHh5o164dkpKSUFFRcc94y8vLMXfuXHTu3BlGoxEmkwkDBw7EP/7xj3vue/z4cYwfPx7t2rWDl5cXvL290blzZ3zyySf43//+Z3cfZe58v379ANSc40GDBqF58+bQarX1XtyttLQUixYtQs+ePWEymeDh4QGz2Yy3337b7oJoyuuPGTMGAHDhwgWr+dhKuTOYTCaEhYUBAL7++muH7Xbt2oXhw4cjMDBQHVEZMGAA0tLSUFVVZdM+Li4OGo0Gw4YNs6mrqKiAj48PNBoNmjVrBhGxaTN48GBoNBpMnz7dqrykpATz589HeHg4TCYTDAYDmjVrhg4dOiAmJgabN2+u7ykgImp03n77bVy5cgXbtm1DZmYm5s+fj88//xyHDx+GVqtFbGys2tZiseDWrVsIDg5WF2r74IMP8OGHH2LgwIEIDQ3FpUuX6h+EEBERPYYSExMFgJjNZhERiYiIEAASGRlp09ZisQgAASA7d+50WGexWBy+ntlsFgCSlpbmcP/NmzeLn5+fAJAmTZqITqdT6/r06SPl5eWyZcsW8fLyEgDi6+srGo1GbRMdHW33tZW+TZ06Vfr06SMARK/Xq6+lbImJiQ7j/81vfiNarVZt6+XlJW5ubur3LVu2lEOHDjk8zxEREZKQkCAARKPRiMlkEp1OV+dr3u3SpUvSqVMn9TUNBoP4+vqq32u1WlmyZInVPr/97W8lICBAmjRporYJCAhQtwkTJtz36yvnMSIiwmGbl156SQCI0Wi0Wx8fH6/Gq9FoxM/Pz+rn3L9/fykoKLDaZ/PmzQJA/P39pbq62qpuz549Vj/Do0ePWtWXl5er10t2drZaXlBQIF26dLGJRa/Xq2XK/w0iosZszpw5dn//iogcOnRIAMjPf/5zu/sqv7eOHTsmIiL79+8XAKLT6cTb21vS0tLk1q1bYrFYJDY2VgBIWFhYvWPkSDcRET0R5s6dCwDYuXMntm3b9khiGDt2LLp27Yqvv/4at2/fRmFhIZYsWQKdTofdu3dj1qxZePPNN/Haa6/h/PnzyM/PR0FBAT755BMANQuE1bVq6tKlS3HgwAEsX74chYWFyMvLUxeEAYCZM2fir3/9q81+a9asweTJk+Hl5YVPP/0UV65cQVFREYqLi5Gbm4v+/fvjypUreP3113Hnzh27r63cgjd58mRcu3YNt27dQlFREX72s5/d17mpqqpS59f5+vpi3bp1uHPnDvLz83H27Fm8+uqrqK6uxsSJE61G7SdNmoSrV69i8eLFAGqmE9Sej62UO0NeXp56p8TTTz9tU/+73/0OCxcuBACMHz8ely9fRl5eHm7fvo2FCxdCr9cjOzvbalQF+H7V9Js3b+Lo0aNWdTt37gQANGnSBACQnZ1tVZ+Tk4Pi4mK4u7sjPDxcLV+8eDGOHj2Kpk2bYvPmzSgpKUFeXh7Kysrw3Xff4fPPP8egQYMe8owQEf2w/etf/wIAXLt2DTNmzLDZTp48CQDqV+X28aqqKsyePRtjxoyByWRCmzZtsHLlSoSFhSEnJwd79uypXyD1TtOJiIgagbtHukVEhg4dKgDk+eeftxpRbKiR7o4dO0ppaanNvqNHj1bbDBw40Ga0U0TUEeyxY8fa1CkjtABkzZo1NvVVVVXSt29fNYbaCgoK1BHxbdu22e1bRUWFdO3aVQDIwoULreqU8wxAEhIS7O5/PzZs2KAeJzMz024MYWFhAkA6depkU5+WlvbQo7eORrorKyslNzdX/RkAkJSUFKs2xcXF0rRpUwEgo0aNsnv8JUuWqPvn5uZa1T3//PMCQBYsWGBVHhkZKQDk17/+tQCQ1157zap+5syZAkD69etnVa6MyCcnJ9fnFBARNTp1jXQnJSVZ3S3kaEtPTxcRkePHj6tlZ8+edXi8u38X3gtHuomI6ImRnJwMnU6HI0eOICMjo8FfPz4+Hu7u7jblgwcPVv89ZcoUu4+iUtr85z//cXj8oKAguyPLWq0W06ZNA1AzF1lZ6RuomYOdn5+PH//4x1Zx1KbX6zFq1CgAcPicaq1Wi8mTJzuM7V42btwIAAgPD7c7AqvX65GYmAigZu557T442759+9CiRQt18/DwQGhoKHbv3g0AiIqKwi9/+UurfbKysnDr1i0AcDiP/b333lOfJ7t+/XqrusjISADWI9llZWXYv38/jEYjEhIS4Obmhn/+859W88KVkXBlf4Wfnx8A4MqVK/XpOhHRY0W5S+izzz6DiDjcYmJiAAAhISHQ6XQAvn8frU0pKykpqVccTLqJiOiJ0b59ezUpnT59+n0tTOZM3bt3t1seEBCg/rtbt251tsnLy3N4fOU2ZXv69OmjPuYkNzdXLd+7dy8A4MSJE1aJ5t3brFmzANQsVGZP27Zt0bx5c4ex3YsS04svvuiwTWRkpPrHUO0+OFtFRQWuXbumbsozWTUaDX7/+9/jiy++gMFgsNpHiScoKAjPPPOM3ePqdDr079/fbvxK+e7du9Wket++fSgtLUXv3r3h6+uLsLAw3L59GwcPHgRQs+jc/v37Adgm3a+++iqAmlveR40ahT//+c8OF8MjInpcKYtfKu+V9+Lh4YGePXsCAL755hubeqWsTZs29YqDSTcRET1RZsyYAU9PT5w7dw7Lly9v0Nf28fGxW177mZ/3alPXBwWBgYEO6zw8PNTHXV2/fl0tv3z5MoCaBK52onn3VlBQAOD7R3Pd7WES7tox3asPTz31lE0fnC0iIkId/SgvL8d///tffPjhhwCAjz76CF999ZXNPvcTPwC0atXKqr2ib9++0Ol0KCgowL///W8A349iKwm58lUZDd+3bx/Kysrg6emp/mGp+OlPf4qJEydCo9Fgw4YNGDp0KJo1a4Z27drh/fffVxN3IqLHWffu3REWFoaMjAz1jqraqqurbd7T3333XQA1fy+UlZWp5SdPnkR6ejp8fHwwZMiQesXBpJuIiJ4ogYGBiIuLAwAkJSU5XBjsSaGMqkZHR9d5652yOXpsmjIC/bgxGAxo27Yt5s2bh8TERBQVFWHEiBFOT/qbNGmCrl27Avg+qVa+Okq6la+9evWCm5ubzTEXLVqEU6dOITk5GS+99BL8/Pxw5swZLF26FKGhofjVr37l1D4QETWU1atXY8yYMRgzZgw2bdpkU7Z69Wq1bUZGBlq3bo2RI0ciPDwc77//PiZNmoQRI0bAbDbbTK0aOXIkhg0bhh07dqBLly6YOHEixowZg27duqG0tBTLli2DyWSqV7xMuomI6IkzZcoUmEwmXL9+HQsWLKizbe1R6NLSUoftbt++7bT4HtR3333nsK6srAw3b94EYD0q3aJFCwCObxtvKEpMdT3/tLS01G4fGsrHH3+MkJAQXL9+3eaZ2PcTf+16e/HXntddVFSEAwcOwM/PDy+88AIAoEePHvD09MTevXtRXl5uk5Tb07ZtW0ydOhVbt27FzZs3sX//fvzkJz8BULPCub3V7ImIfuj27NmDtWvXYu3atTh06BCAmulSSlnt1cWDg4Nx+PBhTJs2DXfu3EFaWhpWrFiBI0eOoG/fvjZrvGg0GmRkZCAlJQV6vR4rVqzAn/70J/Ts2RPZ2dl488036x0vk24iInrimEwmTJkyBQCwYMEC3Lhxo862iosXL9ptc/r0aeTn5zs1xgfx1VdfQUTs1u3evVudmxwaGqqW9+rVC0DNI78e5aJbSkw7duxw2GbXrl1qHxzNfXclg8GgLki3Zs0anD59Wq1T4r906ZJVeW1VVVXqLeP24leS7n379mHHjh2oqKhAREQEtNqaP9fc3NzQq1cvFBcXY/v27ept6HfP53ZEq9WiR48e+OKLL9C6dWsANQvAERE1Nunp6XXelZWenm7V3mQyYfbs2Th27BiKi4tRWFiI06dP4w9/+AOGDh1qc3y9Xo/4+HgcP34cpaWluH37NjIzMxEREfFA8TLpJiKiJ1JcXBxatWqFwsJCzJ4922E7o9GIkJAQADUrfdvz6aefuiTG+vr222+xdu1am/Lq6mokJycDADp06IAf/ehHat3w4cPh5+eHiooKJCQkOEzaleO46sOFkSNHAqhZ7ObLL7+0qa+srFQXc+vUqRM6derkkjju5a233oLZbEZVVRVmzpyplg8cOFCdM+9o9fIVK1aoc+iV1eBr6927NwwGA0pKStSf192j2EqCPWvWLFRWVsLb29vqQxRF7XmId9PpdOrt6EpCT0RErsN3WiIieiJ5enqqydHf/va3OtsqCVJqaiqWLl2qPirk4sWLGDduHDZu3AgvLy+Xxns/fH198e6772LVqlXqrfAXL17EqFGj1BHWpKQkq338/PywaNEiAMCGDRvwyiuvICcnB9XV1QBqEu0TJ05gwYIF6NixI7Zs2eKS2KOiotTFwEaMGIH169eri8ZZLBZERUWpq8/OmzfPJTHcD71ery6qtmHDBnUl29rXU0ZGBt555x1cu3YNQM3ic0uWLFHnUEdHR6vzt2szGo3qCvc5OTkAbJNu5Xulvvaq9LWFhYVhwoQJ2LVrF4qKitTyy5cvIy4uDmfOnAEAvPzyy/U/CUREVD/1eqo3ERFRI5GYmCgAxGw2O2xTWVkp7du3FwDqtnPnTpt2hYWF0qFDB7WNVqsVPz8/ASAGg0EyMjLEbDYLAElLS7Pa12KxqPtZLBa7cezcuVNt40haWprD/kRERAgAmTp1qvTu3VuNy2QyWfVt2rRpDo+/bNkycXNzU9u6u7uLv7+/GAwGq2OsW7fOaj/lPEdERDg89v26dOmSdOzYUX0tNzc39Twr533x4sV2963r/Nwv5Tzeqy8lJSXSokULASDDhg2zqouPj1fj1Wg0YjKZRK/Xq2WRkZFSUFDg8NjTp09X2zZv3tymvqKiQnx8fNQ28+bNs3sc5XpU4vDz8xOj0Wj1s4yPj7/3SSEioofGkW4iInpi6XQ69Tbeunh7e2PPnj1ISEhAcHAw9Ho9DAaDOvqq3Br9qLm5uWHHjh1ITk7Gs88+i7KyMvj6+mLAgAH4+9//Xudt9O+88w5OnTqFSZMmoUuXLnB3d0d+fr56+3JcXByysrLs3hbtLIGBgcjNzUVKSoq6aFhxcTGCgoIwevRoHDx4EBMmTHDZ698vDw8PJCQkAKiZcnD06FG1LiUlBdnZ2YiKikJAQADu3LkDHx8fREZGIjU1FVlZWQ4fCwdYz8+2N1dbr9ejT58+dbYBakbhZ86ciQEDBiA4OBjl5eWoqKiA2WxGdHQ0duzYgZSUlHr3nYiI6k8jUsfkLSIiIiIiIiJ6YBzpJiIiIiIiInIRJt1ERERERERELsKkm4iIiIiIiMhFmHQTERERERERuQiTbiIiIiIiIiIXYdJNRERERERE5CJMuomIiIiIiIhchEk3ERERERERkYsw6SYiIiIiIiJyESbdRERERERERC7CpJuIiIiIiIjIRZh0ExEREREREbkIk24iIiIiIiIiF2HSTUREREREROQi/wdzfXGf/8YjGgAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "axes,ax_inset= plotting_experiments(benchmark_times=READ_TIMES)\n",
    "axes.set_title(\"Benchmark for Create Times\")\n",
    "axes.set_ylabel(\"Read Times (s)\")\n",
    "ax_inset.set_ylabel(\"Read Time (log)\", fontsize=8, labelpad=-2)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Query Times"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\lllang\\AppData\\Local\\Temp\\ipykernel_50988\\211292255.py:5: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n",
      "  plt.tight_layout()\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x600 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "axes,ax_inset= plotting_experiments(benchmark_times=QUERY_TIMES)\n",
    "axes.set_title(\"Benchmark for Query Times\")\n",
    "axes.set_ylabel(\"Query Times (s)\")\n",
    "ax_inset.set_ylabel(\"Query Time (log)\", fontsize=8, labelpad=-2)\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Dicussion"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. **Create Times**  \n",
    "   - **SQLite** scales best for raw inserts: its lightweight B‑tree writer in C outpaces both columnar solutions at every scale (≤ 1 M rows).  \n",
    "   - **ParquetDB** is next.\n",
    "   - **PyArrow** the worst perfromance: this can mainly be attributed to a difference in how the indices are generated.\n",
    "   \n",
    "\n",
    "2. **Read Times**  \n",
    "   - **ParquetDB** & **PyArrow** are effectively identical: both return zero‑copy Arrow tables in ~0.1 s for 1 M rows, thanks to their native columnar layout and batch I/O.  \n",
    "   - **SQLite** is ~40 × slower on full table scans, since it must fetch each row via a cursor and append into Python lists in a tight loop.\n",
    "\n",
    "3. **Query Times**  \n",
    "   - **ParquetDB** & **PyArrow** again match each other closely: filtering 1 M rows takes ~0.3–0.4 s, as Arrow applies vectorized predicates.  \n",
    "   - **SQLite** requires ~1.8 s for the same filter, because every row check is a separate Python‑C transition and Python boolean append.\n",
    "\n",
    "4. **Developer experience & boilerplate**  \n",
    "   - A raw **PyArrow** workflow requires explicit directory management, manual ID generation, repeated calls to `pa.Table.from_pylist()`, `pq.write_table()`, and rebuilding the dataset for each operation—boilerplate that can be tedious to write, maintain, and debug.  \n",
    "   - **ParquetDB** abstracts away all of that: you simply call `db.create(data)`, `db.read()`, or `db.read(filters=…)`. It manages file layouts, row‑group boundaries, indexing, and state under the hood, reducing cognitive load and speeding up development.\n",
    "\n",
    "5. **Key takeaways**  \n",
    "   - ParquetDB’s performance is dominated by the underlying Arrow I/O path—it inherits PyArrow’s blazing read/query speed, with only a small additional cost on table creation.  \n",
    "   - For **write‑heavy** workloads up to ~1 M rows, SQLite still leads on raw insert throughput.  \n",
    "   - For **analytics‑style** workloads (full scans or vectorized filters), the columnar engines (ParquetDB/PyArrow) deliver **an order of magnitude** better performance by avoiding Python‑level loops.  \n",
    "   - For **developer productivity**, ParquetDB’s simple API can save hours of boilerplate code and eliminate error‑prone state management.\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "parquetdb_dev",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.20"
  },
  "nbsphinx": {
   "execute": "never"
  },
  "nbsphinx-thumbnail": {
   "tooltip": "In this example, we benchmark the performance of creates, reads, and queries in ParquetDB, SQLite, and PyArrow."
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
